Java内部类、本地类、匿名类、文件类解读

1. 文件类

package com.wy.jdkclass;

public class ClassTest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassTest classTest = new ClassTest();

// 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象
Dog dog = new Dog();
dog.say();
// 输出结果为：汪汪~~

}
}
/**
* 文件类
* @author wangyang
*/
class Dog {
void say()
{
System.out.println("汪汪~~");
}
}

这种形式的文件类，是我们平时使用最为广泛的类，这样在其他的类中调用的时候，直接用new Object()就可以了，包括调用函数等等的操作也不再赘述。

2. 内部类

package com.wy.jdkclass;

public class ClassTest {

private static String word = "说了句话！";
class Cat {
public void say()
{
System.out.println("喵喵~~");
}
public void saySth()
{
System.out.println("喵喵~~" + word);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassTest classTest = new ClassTest();

// 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象
Dog dog = new Dog();
dog.say();
// 输出结果为：汪汪~~

// 使用内部类
/**
* 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类，
* 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。
* 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
*
* 在调用的时候内部类要通过外面这层类进行调用才行
*/
ClassTest.Cat cat = classTest.new Cat();
cat.say();
// 输出结果为： 喵喵~~

/**
*  下面这段代码说明在内部类中可以直接访问内部的成员变量
*  那么，它是如何实现的呢？
*	是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，
*  于是，可以通过这个引用来访问外围类的成员。
*	通常，这些都是编译器来处理，我们看不到
*/
ClassTest.Cat cat2 = classTest.new Cat();
cat2.saySth();
// 输出结果为：喵喵~~说了句话！

}

}
/**
* 文件类
* @author wangyang
*/
class Dog {
void say()
{
System.out.println("汪汪~~");
}
}

1. 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类，

静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。

内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

2. 内部类中可以直接访问内部的成员变量

那么，它是如何实现的呢？ 

是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。 

通常，这些都是编译器来处理，我们看不到.

3. 匿名内部类

package com.wy.jdkclass;

public class ClassTest {

private static String word = "说了句话！";
class Cat {
public void say()
{
System.out.println("喵喵~~");
}
public void saySth()
{
System.out.println("喵喵~~" + word);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassTest classTest = new ClassTest();

// 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象
Dog dog = new Dog();
dog.say();
// 输出结果为：汪汪~~

// 使用内部类
/**
* 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类，
* 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。
* 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
*
* 在调用的时候内部类要通过外面这层类进行调用才行
*/
ClassTest.Cat cat = classTest.new Cat();
cat.say();
// 输出结果为： 喵喵~~

/**
*  下面这段代码说明在内部类中可以直接访问内部的成员变量
*  那么，它是如何实现的呢？
*	是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，
*  于是，可以通过这个引用来访问外围类的成员。
*	通常，这些都是编译器来处理，我们看不到
*/
ClassTest.Cat cat2 = classTest.new Cat();
cat2.saySth();
// 输出结果为：喵喵~~说了句话！

// 匿名类
/**
* 匿名类
* 匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。
* 匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，
* 而不是创建几个不同匿名类的一个实例。
* 匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。
* 不要在匿名内部类编写其他的方法，是不可见的。
* 形式为：new <类或接口> <类的主体>
*/
new Object(){
public void Say()
{
System.out.println("匿名类输出");
}
}.Say();
// 输出结果：匿名类输出

//匿名内部类重写Dog类的say()方法
new Dog(){
void say()
{
System.out.println("<<汪汪>>");
}
}.say();
// 输出结果：<<汪汪>>

}

public void testForName()
{
try {
System.out.println(Class.forName("java.lang.Object"));
System.out.println(Class.class.toString());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 文件类
* @author wangyang
*/
class Dog {
void say()
{
System.out.println("汪汪~~");
}
}

匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。匿名类的声明是在编译时进行的，

实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。

匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。

不要在匿名内部类编写其他的方法，是不可见的。形式为：new <类或接口> <类的主体>

本质上：匿名类是内部类的一种而已，相互之间可以进行嵌套的，可以自己尝试下效果，下面的例子中给出了部分的嵌套效果：

package com.wy.jdkclass;

public class ClassTest {

private static String word = "说了句话！";
class Cat {
public void say()
{
System.out.println("喵喵~~");
}
public void saySth()
{
System.out.println("喵喵~~" + word);
}
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassTest classTest = new ClassTest();

// 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象
Dog dog = new Dog();
dog.say();
// 输出结果为：汪汪~~

// 使用内部类
/**
* 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类，
* 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。
* 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
*
* 在调用的时候内部类要通过外面这层类进行调用才行
*/
ClassTest.Cat cat = classTest.new Cat();
cat.say();
// 输出结果为： 喵喵~~

/**
*  下面这段代码说明在内部类中可以直接访问内部的成员变量
*  那么，它是如何实现的呢？
*	是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，
*  于是，可以通过这个引用来访问外围类的成员。
*	通常，这些都是编译器来处理，我们看不到
*/
ClassTest.Cat cat2 = classTest.new Cat();
cat2.saySth();
// 输出结果为：喵喵~~说了句话！

// 匿名类
/**
* 匿名类
* 匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。
* 匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，
* 而不是创建几个不同匿名类的一个实例。
* 匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。
* 不要在匿名内部类编写其他的方法，是不可见的。
* 形式为：new <类或接口> <类的主体>
*/
new Object(){
public void Say()
{
System.out.println("匿名类输出");
}
}.Say();
// 输出结果：匿名类输出

//匿名内部类重写Dog类的say()方法
new Dog(){
void say()
{
System.out.println("<<汪汪>>");
}
}.say();
// 输出结果：<<汪汪>>

// 在方法中也可以使用匿名内部类
test();

}

public static void test()
{
// 方法中的匿名内部类
new Object()
{
void say()
{
System.out.println("test---say");
}
}.say();

// 方法中的内部类,只是这个内部类只能在内部调用但是不能在外层的类中进行调用
class Person
{
public void say()
{
// 在内部类的方法中在创建一个内部类那么看看是不是可以进行输出呢
System.out.println("Person say something!");
class PersonSon
{
public void say()
{
System.out.println("i am her son");
}
}
PersonSon persernSon = new PersonSon();
persernSon.say();
//照样输出
}
}
Person person = new Person();
person.say();

}

public void testForName()
{
try {
System.out.println(Class.forName("java.lang.Object"));
System.out.println(Class.class.toString());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 文件类
* @author wangyang
*/
class Dog {
void say()
{
System.out.println("汪汪~~");
}
}