java学习笔记——第10章 多态、包装类、内部类和枚举类（二）

10.2引用类型
在java中，及时释放内存最稳妥的方法就是使用完对象之后立即执行object=null语句。 下面通过四种饮用类型强调垃圾回收方法System.gc()来解决内存泄漏。

10.2.2使用instanceof运算符
instanceof是一个二元操作符，和= =、>、<等是同一类元素。作用是测试它左边的对象是否为右边的类的实例，返回一个boolean类型的instanceof
例子：

public class ceshi{
    public static void main(String args[]) {
        Object hello = "hello";
        System.out.println(hello instanceof Object);
        System.out.println(hello instanceof String);
        System.out.println(hello instanceof Math);
        System.out.println(hello instanceof Comparable);
    }
}

输出：

true
true
false
true

10.3组合
在Java中重复使用一个类，除了把它当作基类继承外，还可以把它当作另一个类的组合成分。
对于继承来说：子类可以直接获得父类的public方法。
对于组合来说：能够把旧类对象作为新类的属性嵌入，我们看到的只是新类的方法，看不到嵌入在对象中的方法。因此通常在新类里面使用private来修饰嵌入的旧类对象。

例子复用：

class dongwu{
    private void beat(){
        System.out.println("休息。。。。");
    }
    public void breath(){
        beat();
        System.out.println("走路。。。。");
    }
}
class niao extends dongwu{
    public void fly(){
        System.out.println("飞翔。。。");
    }
}
class nnn extends dongwu{
    public void run(){
        System.out.println("奔跑。。。");
    }
}
public class fuyong {
    public static void main(String args[]){
        niao b = new niao();
        b.breath();
        b.fly();
        nnn w = new nnn();
        w.breath();
        w.run();
    }
}

输出结果：

休息。。。。
走路。。。。
飞翔。。。
休息。。。。
走路。。。。
奔跑。。。

10.4初始化块
在一个类中可以有多个初始化块。前面定义的初始化块先执行，后面定义的初始化块后执行。在Java中有两种，分别是：静态初始化块和非静态初始化块。

• 静态初始化块：使用static定义，当类装载到系统时执行一次。
• 非静态初始化块：在每个对象生成时都会被执行一次，可以初始化类的实例变量。

例子：

public class ren {
    //下面定义一个初始化块
    {
        int a = 6;
        if (a > 4)
        {
            System.out.println("A说：疏影啊，我们四年没见了吧！");
        }
        System.out.println("B说：看你这脑子，好像6年了吧！");
    }
    //定义第二个初始化块
    {
        System.out.println("A说：你越来越漂亮了啊！");
    }   
    //定义无参数构造器
    public ren(){
        System.out.println("B说：是吗，上学的时候你都不搭理我");
    }
    public static void main(String args[]){
        new ren();
    }
}

输出结果：

A说：疏影啊，我们四年没见了吧！
B说：看你这脑子，好像6年了吧！
A说：你越来越漂亮了啊！
B说：是吗，上学的时候你都不搭理我

10.5使用final修饰符
被final修饰的变量，一旦获得初始值之后，该final变量的值就不能被重新赋值。既可以修饰成员变量、局部变量和形参。
用final修饰变量

1. 修饰类属性时：可在静态初始化块中，声明该属性时指定初始值。
2. 修饰实例属性时：可在非静态初始化块、声明该属性、构造器中制定初始值。

用final修饰局部变量
使用final修饰局部变量时可以指定默认值，也可以不指定默认值，但不管指不指定，都只能赋值一次。
例子：

public class chengyuan {
    final int a =6;
    final String str;
    final int c;
    final static double d;
    {
        str = "hello";
    }
    static{
        d=5.6;
    }
    public chengyuan(){
        c = 5;
    }
    public static void main(String args[]){
        chengyuan tf=new chengyuan();
        System.out.println(tf.a);
        System.out.println(tf.c);
        System.out.println(tf.d);
    }
}

输出：

6
5
5.6

使用final方法
在Java程序中，不能重写final修饰的方法。如果不希望子类重写父类中的某个方法，可以用final来修饰方法。例如下面代码试图重写final方法，执行后会引发编译错误。

public class cuowu{
    public final void test();
}
public Sub extends cowu() {
    public  coid test();
    }    
}

父类是cuowu，在该类中定义的方法test（）是一个final方法，子类试图重写则会引发编译错误。
在Java程序中，对于private方法来说，因为它仅在当前类中可见，子类无法访问该方法。因此子类可以“重写（重载）”父类的private final方法。
例如：

public class chongsi{
    private final void test(){}
}
class mmm extends chongsi{
    public void test(){}
}

不会出任何问题。
例子：在子类中设置不重写父类中的某个方法

class Parents{
    private final void doit(){
        System.out.println("A说，我比你胖");
    }
    final void doit2(){
        System.out.println("B说我比你高");
    }
    public void doit3(){
        System.out.println("C说我比你俩苗条！");
    }
}
class Sub extends Parents{
    public final void doit(){
        System.out.println("D说：你是我儿媳妇");
    }
    //final void doit2(){}会报错，不能覆盖
    public void doit3(){
        System.out.println("A说的话怎么不见了？");
    }
}
public class FinalMathod {
    public static void main(String args[]){
        Sub s = new Sub();
        s.doit();
        Parents p = s;
        p.doit2();
        p.doit3();
    }
}

输出结果：

D说：你是我儿媳妇
B说我比你高
A说的话怎么不见了？

使用final类
在Java程序中，被定义为final的类不能被继承。