黑马程序员-学习日记（接口和多态）

 

继承

 

通过 extends 关键字让类与类之间产生继承关系。

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。

注意：

①子类可以直接访问父类中的非私有的属性和行为。

②子类无法继承父类中私有的内容。
③父类怎么来的？共性不断向上抽取而来的。

ExtendDemo.java
class Person{
      String name;
      int age ;
}

class Student extends Person{
       void study(){
            System. out.println("student study..." + age);
      }
}

class Worker extends Person{
       void work(){
            System. out.println("worker work..." + age);
      }
}

class ExtendDemo{
       public static void main(String[] args){
            Student s = new Student();
            s. name = "zhangsan" ;
            s. age = 20;
            s.study();

            Worker w = new Worker();
            w. name = "lisi" ;
            w. age = 30;
            w.work();
      }
}

好处：

继承的出现提高了代码的复用性。继承的出现让类与类之间产生了关系，提供了多态的前提。

 

继承的特点

Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。

原因：因为多继承容易出现问题。两个父类中有相同的方法。子类到底要执行哪一个是不确定的。

class A{
       void show(){
            System. out.println("a" );
      }
}
class B{
       void show(){
            System. out.println("b" );
      }
}
class C extends B,A{

}

那么创建类C的对象，调用show方法就不知道调用类A中的show方法还是类B中的show方法。

所以java是不支持多继承，但将这种机制以另一种安全的方式来体现，也就是多实现。

 

Java支持多层继承(继承体系)

C继承B，B继承A，就会出现继承体系。

多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。

 定义继承需要注意：
不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( "is a")关系。
 

 super关键字 & 函数覆盖

 在子父类中，成员的特点体现：
①成员变量

this和super的用法很相似。this代表本类对象的引用。super代表父类的内存空间的标识。

当本类的成员和局部变量同名用this区分。当子父类中的成员变量同名用super区分父类。

//ExtendDemo.java
class Fu{
       private int num = 4;
       public int getNum(){
             return num ;
      }
}

class Zi extends Fu{
       private int num = 5;  
       void show(){
            System. out.println(this.num + "..." + super.getNum());
      }
}

class ExtendDemo{
       public static void main(String[] args){
            Zi z = new Zi();
            z.show();
      }
}

②成员函数

当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作，这是函数在子父类中的特性。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

 函数两个特性：

1、重载，同一个类中。
2、覆盖，子类中，覆盖也称为重写，覆写，override。

class Fu{
       public void show(){
            System. out.println("fu show run" );
      }
}

class Zi extends Fu{
       public void show(){
            System. out.println("zi show run" );
      }
}

class ExtendDemo{
       public static void main(String[] args){
            Zi z = new Zi();
            z.show();
      }
}

什么时候使用覆盖操作？

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

class Phone{
       void call(){}
       void show(){
            System. out.println("number" );
      }
}

class NewPhone extends Phone{
       void show(){
            System. out.println("name" );
            System. out.println("pic" );
            super.show();
      }
}

class ExtendDemo{
       public static void main(String[] args){
            NewPhone p = new NewPhone();
            p.show();
      }
}

注意：

①父类中的私有方法不可以被覆盖。②父类为static的方法无法覆盖。③覆盖时，子类方法权限一定要大于等于父类方法权限。

class Fu{
       public void show(){
            System. out .println("fu show run" );
      }
}

class Zi extends Fu{
       private void show(){
            System. out .println("zi show run" );
      }
}

class ExtendDemo{
       public static void main(String[] args){
            Zi z = new Zi();
            z. show();
      }
}

③构造函数

子父类中构造函数的特点：
在子类构造函数执行时，发现父类构造函数也运行了。
原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();。

注意：如果使用super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。

class Fu{
      int num ;
      Fu(){
            num = 10;
            System. out.println("A fu run" );
      }
      Fu( int x){
            System. out.println("B fu run..." + x);
      }
}

class Zi extends Fu{
      Zi(){
            //super();//默认调用的就是父类中的空参数的构造函数
            System. out.println("C zi run " + num);
      }
      Zi( int x){
            super(4);
            System. out.println("D zi run " + x);
      }
}

class ExtendDemo{
       public static void main(String[] args){
            new Zi();
            System. out.println("-------------------" );
             new Zi(6);
      }
} 

--------------------------------------------------------------------------------------------------------------------

子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数。
因为每一个构造函数的第一行都有一条默认的语句super();。

子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

 

为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。

 

注意：

①当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

②子类构造函数中如果使用this调用了本类构造函数，那么默认的super();就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

③super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。

ExtendDemo.java
class Fu{
      Fu()
　　　　　{
             super();
             show();
             return;
      }
       void show(){
            System. out.println("fu show" );
      }
}
class Zi extends Fu{
       int num = 8;
       Zi(){
             super();
             //通过super初始化父类内容时，子类的成员变量并未显示初始化，等super()父类初始化完毕后，才进行子类的成员变量显示初始化
             return;
      }
       void show(){
            System. out.println("zi show..." + num);
      }
}
class ExtendDemo{
       public static void main(String[] args){
            Zi z = new Zi();//调用的是子类的show方法，此时其成员变量 num还未进行显示初始化
            z.show();
      }
}

不正确的案例：

class fu
{
    fu(int num)
    {
        show();
        return;
    }
    void show()
    {
        System.out.println("fu show");
    }
}

class zi extends fu
{
    int num = 9;
    zi()
    {return;
    }
    void show()
    {
        System.out.println("zi show"+num);
    }
}

总结：

一个对象实例化过程，以Person p = new Person();为例：
1、JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。
2、在内存中开辟空间，并分配地址。
3、并在对象空间中，对对象的属性进行默认初始化。
4、调用对应的构造函数进行初始化。
5、在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6、父类初始化完毕后，再对子类的属性进行显示初始化。
7、再进行子类构造函数的特定初始化。
8、初始化完毕后，将地址值赋值给引用变量。

 --------------------------------------------------------------------------------------------------------------------------

final关键字

final可以修饰类，方法，变量。
final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量，只能被赋值一次。
为什么要用final修饰变量，其实在程序中如果一个数据是固定的。
那么直接使用这个数据就可以了，但是这种阅读性差，所以应该给数据起个名称。
而且这个变量名称的值不能变化，所以加上final固定。
写法规范：常量所有字母都大写，多个单词，中间用_连接。

FinalDemo.java
//继承弊端：打破了封装性
class Fu{
       void method(){
      }
}

class Zi extends Fu{
       public static final double PI = 3.14;
       void method(){
            System. out.println(PI);
      }
}

class FinalDemo{
       public static void main(String[] args){
            Zi zi = new Zi();
            zi.method();
      }
}

//FinalDemo.java
class FinalDemo{
       public static void main(String[] args){
            final int x = 4;
            x = 5;
      }
}

---------------------------------------------------------------------------------------------------------

抽象类

概述

抽象定义：
抽象就是从多个事物中将共性的，本质的内容抽取出来。
例如：猫和虎共性都是猫科，猫科就是抽象出来的概念。
抽象类：
Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：

//AbstractDemo.java
abstract class Demo{
       abstract void show();
}
class DemoA extends Demo{
       void show(){
            System. out.println("demoa show" );
      }
}
class DemoB extends Demo{
       void show(){
            System. out.println("demob show" );
      }
}
class AbstractDemo{
       public static void main(String[] args){
            DemoA demoA = new DemoA();
            demoA.show();
            DemoB demoB = new DemoB();
            demoB.show();     
      }
}

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
例如：猫和虎都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的猫科虽然有吼叫功能，但是并不明确吼叫的细节。

-------------------------------------------------------------------------------------------------------------------

抽象类举例代码讲解雇员示例

需求：

公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。

分析：

在这个问题领域中，通过名词提炼法：
程序员：
     属性：姓名，工号，薪水。
     行为：工作。
经理：
     属性：姓名，工号，薪水，奖金。
     行为：工作。

 

程序员和经理不存在着直接继承关系。

但是，程序员和经理却具有共性内容，可以进行抽取，因为他们都是公司的雇员。

可以将程序员和经理进行抽取，建立体系。

//描述雇员。
abstract class Employee{
       private String name ;
       private String id ;
       private double pay ;

      Employee(String name,String id, double pay){
             this.name = name;
             this.id = id;
             this.pay = pay;
      }

       public abstract void work();
}

//描述程序员
class Programmer extends Employee{
      Programmer(String name,String id, double pay){
             super(name,id,pay);
      }

       public void work(){
            System. out.println("code..." );
      }
}

//描述经理
class Manager extends Employee{
       private int bonus ;
      
      Manager(String name,String id, double pay,int bonus){
             super(name,id,pay);
             this.bonus = bonus;
      }

       public void work(){
            System. out.println("manage" );
      }
}

--------------------------------------------------------------------------------------------------

抽象类相关问题

抽象类中是否有构造函数？

答：有，用于给子类对象进行初始化。

抽象关键字abstract不可以和哪些关键字共存？

答：private、static、final。

抽象类中可不可以没有抽象方法？

答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo{
     void show1(){}
     void show2(){}
}

抽象类和一般类的区别？

答：

相同点：
抽象类和一般类都是用来描述事物的，都在内部定义了成员。

不同点：
①一般类有足够的信息描述事物。 抽象类描述事物的信息有可能不足。
②一般类中不能定义抽象方法，只能定义非抽象方法。 抽象类中可定义抽象方法，同时也可以定义非抽象方法。
③一般类可以被实例化。抽象类不可以被实例化。

 

抽象类一定是个父类吗？

答：是的，因为需要子类覆盖其方法后才可以对子类实例化。

------------------------------------------------------------------------------------------------------------------

 

接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。

 格式：interface {}

接口中的成员修饰符是固定的：
成员常量：public static final
成员函数：public abstract

由此得出结论，接口中的成员都是公共的权限。接口是对外暴露的规则。接口是程序的功能扩展。

 注意：

①虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。

②类与类之间是继承关系，类与接口直接是实现关系。

③接口不可以实例化,只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。

interface Demo{
       public static final int NUM = 4;
       public abstract void show1();
       public abstract void show2();
}

class DemoImpl implements /*实现*/Demo{
       public void show1(){}
       public void show2(){}
}

class InterfaceDemo{
       public static void main(String[] args){
            DemoImpl d = new DemoImpl();
            System. out.println(d.NUM);
            System. out.println(DemoImpl.NUM);
            System. out.println(Demo.NUM);
      }
}

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

在java中不直接支持多继承，因为会出现调用的不确定性。

所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。

接口的出现避免了单继承的局限性。

interface A{
       public void show();
}

interface Z{
       public void show();
}

//多实现
class Test implements A,Z{
       public void show(){
            System.out.println("Test");
      }
}

class InterfaceDemo{
       public static void main(String[] args){
            Test t = new Test();
            t.show();
      }
}

一个类在继承另一个类的同时，还可以实现多个接口。

 

interface A{
       public void show();
}
interface Z{
       public void show();
}
class Q{
    public void method(){
    }
}
abstract class Test2 extends Q implements A,Z{
 }

 

interface CC{
       void show();
}

interface MM{
       void method();
}

//接口与接口之间是继承关系，而且接口可以多继承
interface QQ extends CC,MM{
       public void function();
}

class WW implements QQ{
       //覆盖3个方法
       public void show(){}
       public void method(){}
       public void function(){}
} 

抽象类和接口的异同点？
相同点：
都是不断向上抽取而来的。
不同点：
①抽象类需要被继承，而且只能单继承。
   接口需要被实现，而且可以多实现。
②抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
   接口中只能定义抽象方法，必须由子类去实现。
③抽象类的继承，是is a关系，定义该体系的基本共性内容。
   接口的实现是like a关系。

接口应用综合案例：

/*
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。
*/
interface USB{//暴露的原则
       public void open();
       public void close();
}

//实现原则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
       public void open(){
            System. out.println("upan open" );
      }
       public void close(){
            System. out.println("upan close" );
      }
}

class UsbMouse implements USB{
       public void open(){
            System. out.println("usbMouse open" );
      }
       public void close(){
            System. out.println("usbMouse close" );
      }
}

class BookPC{
       public static void main(String[] args){
             //功能扩展了
             useUSB(new UPan());
      }
       //使用原则
       public static void useUSB(USB u){//接口类型的引用，用于接收（指向）接口的子类对象
             if(u != null ){
                  u.open();
                  u.close();
            }
      }
}

 

 -------------------------------------------------------------------------------------------------------------

多态

定义：某一类事物的多种存在形态。
例：动物中猫，狗。
猫这个对象对应的类型是猫类型：猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物：动物  y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。

多态性简单说就是一个对象对应着不同类型。

 

体现：
父类或者接口的引用指向或者接收自己的子类对象。
作用：
多态的存在提高了程序的扩展性和后期可维护性。

前提：
①需要存在继承或者实现关系。
②需要有覆盖操作。

好处：

提高了代码的扩展性，前期定义的代码可以使用后期的内容。
弊端：
前期定义的内容不能使用（调用）后期子类的特有内容。

DuoTaiDemo.java
abstract class Animal{
       abstract void eat();
}

class Dog extends Animal{
       void eat(){
            System. out.println("啃骨头" );
      }
       void lookHome(){
            System. out.println("看家" );
      }
}

class Cat extends Animal{
       void eat(){
            System. out.println("吃鱼" );
      }
       void catchMouse(){
            System. out.println("抓老鼠" );
      }
}

class Pig extends Animal{
       void eat(){
            System. out.println("饲料" );
      }
       void gongdi(){
            System. out.println("拱地" );
      }
}

class DuoTaiDemo{
       public static void main(String[] args){
            Cat c = new Cat();
            Dog d = new Dog();

             method(c);
             method(d);
             method(new Pig());
      }

       public static void method(Animal a){
            a.eat();
      }
}

class DuoTaiDemo{
     public static void main(String[] args){
          //自动类型提升，猫对象提升了动物类型。但是特有功能无法访问，作用就是限制对特有功能的访问。
          //专业讲：向上转型，将子类型隐藏。就不能使用子类的特有方法了。
          Animal a = new Cat();
          a.eat();
          //a.catchMouse();//报错

          //如果还想用具体动物猫的特有功能。
          //你可以将该对象进行向下转型。
          Cat c = (Cat)a; //向下转型的目的是为了能够使用子类中的特有方法。
          c.eat();
          c.catchMouse();

          //注意：对于转型，自始至终都是子类对象在做类型的变化。
          //Animal a = new Dog();
          //Cat c = (Cat)a;//但是类型不能随意转换，否则可能会报出ClassCastException的异常
     }

     public static void method(Animal a){
          a.eat();
     }

/*
毕老师和毕姥爷的故事
*/
class 毕姥爷{
       void 讲课(){
            System. out.println("管理" );
      }
       void 钓鱼(){
            System. out.println("钓鱼" );
      }
}

class 毕老师 extends 毕姥爷{
       void 讲课(){
            System. out.println("Java" );
      }
       void 看电影(){
            System. out.println("看电影" );
      }
}

class DuoTaiDemo{
       public static void main(String[] args){
            毕老师 x = new 毕老师();
            x.讲课(); //Java
            x.看电影(); //看电影

            毕姥爷 y = new 毕老师();
            y.讲课(); //Java
            y.钓鱼(); //钓鱼

            毕老师 z = (毕老师)y;
            z.看电影(); //看电影
      }
}

注意：

instanceof ：用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性的判断。

class DuoTaiDemo{
       public static void main(String[] args){
            
      }

       public static void method(Animal a){
            a.eat();
            
             if(a instanceof Cat){ 
                  Cat c = (Cat )a;
                  c.catchMouse();
            }
             else if (a instanceof Dog){
                  Dog d = (Dog )a;
                  d.lookHome();
            }
      }
}

 多态时，成员的特点：
①成员变量
     编译时：参考引用型变量所属的类中是否有调用的成员变量。有，编译通过，没有，编译失败。
     运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
     简单说：编译和运行都参考等号的左边。

class Fu{
       int num = 3;
}

class Zi extends Fu{
       int num = 4;
}

class DuoTaiDemo{
       public static void main(String[] args){
            Zi f1 = new Zi();
            System. out.println(f1.num );
            Fu f2 = new Zi();
            System. out.println(f2.num );
      }
}

②成员函数（非静态）
     编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。
     运行时：参考的是对象所属的类中是否有调用的函数。
     简单说：编译看左边，运行看右边。

DuoTaiDemo.java
class Fu{
       void show(){
            System. out.println("fu show" );
      }
}

class Zi extends Fu{
       void show(){
            System. out.println("zi show" );
      }
}

class DuoTaiDemo{
       public static void main(String[] args){
            Fu f = new Zi();
            f.show();
      }
}

③静态函数
     编译时：参考的是对象所属的类中是否有调用的函数。
     运行时：参考的是对象所属的类中是否有调用的函数。
     简单说：编译和运行都看左边。

 

class Fu{
       static void method(){
            System. out.println("fu static method" );
      }
}

class Zi extends Fu{
       static void method(){
            System. out.println("zi static method" );
      }
}

class DuoTaiDemo{
       public static void main(String[] args){
            Fu f = new Zi();
            f.method();// fu static method
            Fu. method();
      }
}

 

内部类的设计：  InnerClassDemo.java

/*
内部类的设计：
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义内部类。
*/
class Outer{
       private int num = 3;

       class Inner //内部类
      {
             void show(){
                  System. out.println("show run..." + num);
            }
      }

       public void method(){
            Inner in = new Inner();
            in.show();
      }
}

class InnerClassDemo{
       public static void main(String[] args){
            Outer out = new Outer();
            out.method();
      }
}

class Outer{
       private int num = 3;
       class Inner
      {
             void show(){
                  System. out.println("show run..." + num);
            }
      }
}

class InnerClassDemo{
       public static void main(String[] args){
             //直接访问外部类中的内部类中的成员
            Outer.Inner in = new Outer().new Inner();
            in.show();
      }
}

内部类的位置

内部类定义在成员位置上,可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

class Outer{
       private static int num = 3;

       static class Inner
      {
             void show(){
                  System. out.println("show run..." + num);
            }
      }
}

class InnerClassDemo{
       public static void main(String[] args){
             //如果内部类是静态的，相当于一个外部类
            Outer.Inner in = new Outer.Inner();
            in.show();
      }
}

class Outer{
       private static int num = 3;

       static class Inner
      {
             static void show(){
                  System. out.println("show run..." + num);
            }
      }
}

class InnerClassDemo{
       public static void main(String[] args){
            Outer.Inner.show();
      }
}

注意：①如果内部类中定义了静态成员，该内部类也必须是静态的！

class Outer{
     private static int num = 3;

     static class Inner
     {
          static void show(){
               System. out.println("show run..." + num);
          }
     }
}

②为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。

 

InnerClassDemo.java
class Outer{
       int num = 3;
       class Inner{
             int num = 4;
             void show(){
                   int num = 5;
                  System. out.println(num);
                  System. out.println(this.num);
                  System. out.println(Outer.this.num);
            }
      }
       void method(){
             new Inner().show();
      }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method();
      }
}

 

③内部类定义在局部位置上，也可以直接访问外部类中的成员。

同时可以访问所在局部中的局部变量，但必须是被final修饰的。

class Outer{
       int num = 3;
       void method(final int y){
             final int x = 9;
             class Inner{
                   void show(){
                        System. out.println("show..." + x + "," + y);
                  }
            }
            Inner in = new Inner();
            in.show();
      }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method(4);
      }
}

匿名内部类

定义：

就是内部类的简化写法。
前提：
内部类可以继承或实现一个外部类或者接口。
格式：
new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。

什么时候使用匿名内部类呢？
通常在使用方法是接口类型参数，并且该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
好处：

增强阅读性。

abstract class Demo{
       abstract void show();
}

class Outer{
       int num = 4;

       void method(){
             new Demo(){//匿名内部类
                   void show(){
                        System. out.println("show......" + num);
                  }
            }.show();
      }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method();
      }
}

interface Inter{
       void show1();
       void show2();
}

class Outer{
       public void method(){
            Inter in = new Inter(){
                   public void show1(){
                          System. out.println("...show1...." );
                  }
                   public void show2(){
                          System. out.println("...show2...." );
                  }
            };
            in.show1();
            in.show2();
      }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method();
      }
}

interface Inter{
       void show1();
       void show2();
}

/*
通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递。
*/
class InnerClassDemo{
      public static void main(String[] args){
             show(new Inter(){
                   public void show1(){
                        System. out.println("...show1..." );
                  }
                   public void show2(){
                        System. out.println("...show2..." );
                  }
            });
      }
       public static void show(Inter in){
            in.show1();
            in.show2();
      }
}

对象的初始化过程实例：

class Fu{
       int num = 9;

      {
            System. out.println("Fu" );
      }

      Fu(){
             super();//Object
             //显示初始化
             //构造代码块初始化
            show();
      }
       void show(){
            System. out.println("fu show " + num);//被覆盖，运行子类的
      }
}

class Zi extends Fu{
       int num = 8;

      {
            System. out.println("Zi" );
      }

      Zi(){
             super();
             //显示初始化
             //构造代码块初始化
            show();
      }

       void show(){
            System. out.println("zi show " + num); 
      }
}

public class Demo{
       public static void main(String[] args){
             new Zi();
      }
}