基本概念
在面向对象的概念中，我们知道所有的对象都是通过类来描绘的。
在 Java 中类通过关键字 class 来定义。
同样的在 Java 中类具有多种形式，包括普通类、抽象类、内部类。
其中内部类又包含了：成员内部类、局部内部类、匿名内部类、静态内部类。
立即学习“Java免费学习笔记（深入）”；
普通类
这个没什么好说的。
public class Demo { }抽象类
1.基本概念
上面提到所有的对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的。
如果一个类中没有包含足够的信息来描绘一个具体的对象（我们可以理解为一种功能不全的类），这样的类就是抽象类。
抽象类通过关键字 absract 定义。它可以包含抽象方法、非抽象方法。
2.实例探究
抽象类定义
public abstract class Parent {
// 1.成员变量，与普通类无差别
private String word="aa"; // 2.非抽象方法，与普通类无差
private void talk(){
System.out.println("Parent is talking");
} // 3.抽象方法，访问权限只能是 public 和 protected
abstract void print();
}抽象类继承
// 1.抽象类继承抽象类，抽象子类不用实现父类的方法public abstract class Son extends Parent { }
// 2.普通类继承抽象类，普通子类必须实现父类的所有抽象方法public class Grandson extends Son {
@Override
void print() {
System.out.println("I am Grandson");
}
}抽象类调用
// 错误，抽象类不允许被实例化//Parent parent = new Parent();
通过以上的代码，我们可以总结出这么几点：
抽象类、抽象方法，不能被 private 修饰，且必须使用关键字 abstract 定义。
子类如果不是抽象类，则必须实现父类所有的抽象方法。
抽象类不允许被实例化，编译错误。
抽象类里面也可以包含普通方法，成员变量。
成员内部类
1.基本概念
位于一个类内部的类，被称为成员内部类。
成员内部类具有以下特点：可以访问其外围类的所有属性，而不需要任何特殊条件。
2.实例探究
成员内部类定义：
public class Outter {
private int a = 10; static int b = 20; int c = 30; // 内部类
class Inner { void print(int d) {
System.out.println(a + "-" +b+ "-" +c+ "-" + "-" +d;
}
} // 取得内部类
Inner getInner() { return new Inner();
}
}成员内部类调用
Outter out = new Outter();// 创建内部类的两种方式： Outter.Inner inner = out.new Inner();Outter.Inner inner2 = out.getInner();inner.print(20);
3.原理分析
通过反编译 class 文件，命令如下：
javap -v Outter
执行命令后，后得到两个 class 文件：Outter.Class 和 Outter$Inner.Class。
说明对于虚拟机来说，内部类其实与常规类是一样的。所以 Inner 仍然被编译成一个独立的类，而不是 Outter 类的某一个域。
但是由于成员内部类看起来像是外部类的一个成员，所以可以拥有与成员一样的访问权限。
局部内部类
1.基本概念
局部内部类有两种：
方法内的类。
作用域内的类。
可以将其视作方法或作用域的内局部变量，因此它的访问权限也仅限于方法内或者该作用域内。
同局部变量一样，它是无法被 public、protected、private、static 关键字修饰的。
2.实例探究
public class Man {
public Object getWoman() { // 注意：三个变量都相互不受影响
int age = 30; // 1.方法内的类
class Woman { int age = 20;
} // 2.作用域内的类，此时作用域为 if
if(true){
class Son{ int age = 10;
}
}
return new Woman();
}
}匿名内部类
1.基本概念
匿名内部类是唯一一种没有构造器的类。因为这个特点，匿名内部类的使用范围非常有限，大部分用于接口回调。
它具有以下特点：
匿名内部类在编译的时候由系统自动起名为 Outter$1.class。
匿名内部类一般用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
匿名内部类不能访问外部类方法中的局部变量，除非变量被声明为 final 类型
2.实例探究
public class Test {
// a 属于全局变量
int a =100; public static void main(String[] args) {
Test t = new Test();
t.test(200);
} // b 属于局部变量
public void test(final int b) { // c 属于局部变量
final int c = 300; // 匿名内部类
new Thread() { int d = 400; public void run() {
System.out.println(a+"-"+b+"-"+c+"-"+d);
};
}.start();
}
}3.原理分析
通过反编译命令可以得到两个 class 文件：Outter.class 和 Outter$1.class。
关于局部变量的生命周期：
当方法被调用时，局部变量在栈中被创建。当方法运行结束后，退栈，局部变量死亡。
关于内部类对象的声明周期：
创建一个匿名内部类对象，系统为该对象分配内存，直到没有引用变量指向分配给该对象的内存，它才会被 GC 处理。
因此存在情况：
成员方法已调用结束，局部变量已死亡，但匿名内部类的对象仍然活着。
所以在 Java 中采用了 final 关键字+复制的办法来解决：
final 关键字：因为它的特性是一旦变量被赋值后，就不能被修改。
复制：在匿名内部类中直接复制了一个与局部变量值的数，让它变成自己的局部变量。
所以当局部变量的生命周期结束后，匿名内部类照样可以访问 final 类型的局部变量，因为它自己拷贝了一份，且与原局部变量的值始终一致。
下面针对上面的代码来分析：
当 test 方法执行完毕之后，变量 b、c 的生命周期就结束了。然而 Thread 对象的生命周期很可能还没有结束。因此要将 b、c 设置为 final 。
a 之所以不采用 final 修饰，因为它是全局变量，生命周期是随着类的结束而结束。而类的生命周期肯定大于匿名内部类。
静态内部类
1.基本概念
静态内部类也是定义在一个类里面的类，只不过在类的前面多了一个关键字static。
静态内部类和静态成员变量其实具有相同的特点：
它只有类有关，与对象无关。因此可以在没有外部类对象情况下，创建静态内部类。
不能访问外部类的非静态成员或方法
2.实例探究
内部静态类定义：
public class Outter {
int a = 5; static int b = 500; // 静态内部类
static class Inner { public Inner() { // 只能访问外部类的静态成员
System.out.println(b);
}
}
}静态内部类调用：
// 静态内部类的调用不依赖外部类对象Outter.Inner inner= new Outter.Inner();
接口内部类
1.基本概念
接口内部类，顾名思义就是在接口内定义的类。
2.实例探究
接口内部类定义：
public interface People{
class Man { public void print() {
System.out.println("man.print()...");
}
}
}接口内部类调用：
People.Man man = new People.Man();
以上就是04.Java 基础 - 类的内容，更多相关内容请关注PHP中文网（www.php.cn）！
