在面向对象的概念中,我们知道所有的对象都是通过类来描绘的。
在 Java 中类通过关键字 class 来定义。
同样的在 Java 中类具有多种形式,包括普通类、抽象类、内部类。
其中内部类又包含了:成员内部类、局部内部类、匿名内部类、静态内部类。
这个没什么好说的。
public class Demo { }
上面提到所有的对象都是通过类来描绘的,但是并不是所有的类都是用来描绘对象的。
如果一个类中没有包含足够的信息来描绘一个具体的对象(我们可以理解为一种功能不全的类),这样的类就是抽象类。
抽象类通过关键字 absract 定义。它可以包含抽象方法、非抽象方法。
抽象类定义
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 定义。
子类如果不是抽象类,则必须实现父类所有的抽象方法。
抽象类不允许被实例化,编译错误。
抽象类里面也可以包含普通方法,成员变量。
位于一个类内部的类,被称为成员内部类。
成员内部类具有以下特点:可以访问其外围类的所有属性,而不需要任何特殊条件。
成员内部类定义:
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);
通过反编译 class 文件,命令如下:
javap -v Outter
执行命令后,后得到两个 class 文件:Outter.Class 和 Outter$Inner.Class。
说明对于虚拟机来说,内部类其实与常规类是一样的。所以 Inner 仍然被编译成一个独立的类,而不是 Outter 类的某一个域。
但是由于成员内部类看起来像是外部类的一个成员,所以可以拥有与成员一样的访问权限。
局部内部类有两种:
方法内的类。
作用域内的类。
可以将其视作方法或作用域的内局部变量,因此它的访问权限也仅限于方法内或者该作用域内。
同局部变量一样,它是无法被 public、protected、private、static 关键字修饰的。
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(); } }
匿名内部类是唯一一种没有构造器的类。因为这个特点,匿名内部类的使用范围非常有限,大部分用于接口回调。
它具有以下特点:
匿名内部类在编译的时候由系统自动起名为 Outter$1.class。
匿名内部类一般用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的实现或是重写。
匿名内部类不能访问外部类方法中的局部变量,除非变量被声明为 final 类型
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(); } }
通过反编译命令可以得到两个 class 文件:Outter.class 和 Outter$1.class。
关于局部变量的生命周期:
当方法被调用时,局部变量在栈中被创建。当方法运行结束后,退栈,局部变量死亡。
关于内部类对象的声明周期:
创建一个匿名内部类对象,系统为该对象分配内存,直到没有引用变量指向分配给该对象的内存,它才会被 GC 处理。
因此存在情况:
成员方法已调用结束,局部变量已死亡,但匿名内部类的对象仍然活着。
所以在 Java 中采用了 final 关键字+复制的办法来解决:
final 关键字:因为它的特性是一旦变量被赋值后,就不能被修改。
复制:在匿名内部类中直接复制了一个与局部变量值的数,让它变成自己的局部变量。
所以当局部变量的生命周期结束后,匿名内部类照样可以访问 final 类型的局部变量,因为它自己拷贝了一份,且与原局部变量的值始终一致。
下面针对上面的代码来分析:
当 test 方法执行完毕之后,变量 b、c 的生命周期就结束了。然而 Thread 对象的生命周期很可能还没有结束。因此要将 b、c 设置为 final 。
a 之所以不采用 final 修饰,因为它是全局变量,生命周期是随着类的结束而结束。而类的生命周期肯定大于匿名内部类。
静态内部类也是定义在一个类里面的类,只不过在类的前面多了一个关键字static。
静态内部类和静态成员变量其实具有相同的特点:
它只有类有关,与对象无关。因此可以在没有外部类对象情况下,创建静态内部类。
不能访问外部类的非静态成员或方法
内部静态类定义:
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();
接口内部类,顾名思义就是在接口内定义的类。
接口内部类定义:
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)!