04.Java 基础 - 类

基本概念

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的。

在 Java 中类通过关键字 class 来定义。

同样的在 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();

---

参考

• http://www.cnblogs.com/dolphin0520/p/3811445.html