Java语言基础面向对象(继承)

设计模式

    单例设计模式
    解决的问题：可以保证一个类在内存中的对象唯一性。

    必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。
    方法：
        1.不允许其他程序用new创建该类对象；
        2.在该类中创建一个本类实例；
        3.对外提供一个方法让其他程序可以获取该对象。
    步骤：
        1.私有化该类的构造函数；
        2.通过new在本类中创建一个本类的对象；
        3.定义一个公有的方法，将创建的对象返回。
   

/*
    设计模式：对问题行之有效的解决方式。其实它是一种思想。
    */
    //饿汉式
    class Single//类一加载，对象就已经存在
    {
        private static Single s=new Single();//在本类中创建对象
        private Single(){};//私有化构造函数
        public static Single getInstance()//公有方法，返回对象
        {
            return s;
        }
    }

    //懒汉式
    class Single2//类加载进来，没有对象；只有调用了getInstance时，才会创建对象
                        //延迟加载形式
    {
        private static Single s=null;
        private Single2(){};
        public static Single2 getInstance()
        {
            if(s==null)
                s=new Single2();
            return s;
        }
    }

    class SingleDemo 
    {
        public static void main(String[] args) 
        {
            Single s1= Single.getInstance();
            Single s2= Single.getInstance();
            System.out.println(s1==s2);
            //Single ss=Single.s; 
        }
    }

继承
    继承的好处：
    1.提高了代码的复用性；
    2.让类与类之间产生了关系，给第三个特征多态提供了前提；

    Java中支持单集成。不直接支持多继承，但对C++中的多继承机制进行改良；
        单继承：一个子类只能有一个直接父类；
        多继承：一个子类可以有多个直接父类（在Java不允许，进行改良）；
                                 不直接支持，是因为多个父类中有相同成员，会产生调用的不确定性；
                                 在Java中是通过“多实现”的方式来体现的；
           
    Java支持多层（多重）继承
        C继承B，B继承A，就会出现集成体系；
    当要是用一个集成体系时：
    1.查看该体系中的顶层类，了解该体系的基本功能；
    2.创建体系中的最子类对象，完成功能的使用；

    什么时候定义继承？
    当类与类之间存在所属关系的时候，就定义继承（父类中的功能，如果子类都需要具备，就定义继承）；
    所属关系：“is a”关系；

    本类中有的成员变量，不在父类中查找；
    当本类的成员和局部变量同名，用this区分；
    当子父类中的成员变量同名，用super区分父类，super代表父类；
    私有成员，子类能够继承，但是不能被直接访问（子类不能直接访问父类中私有的内容）；

    this和super的用法很相似
    this：代表一个本类对象的引用；
    super ：代表一个父类空间；

//成员变量
    class Fu
    {
        private int num=4;//私有成员，子类能够继承，但是不能被直接访问（子类不能直接访问父类中私有的内容）
    }

    class Zi extends Fu
    {
        private int num=5;
        void show()
        {
            /*本类中有的成员变量，不在父类中查找*/
            System.out.println(this.num+"......"+super.num);//这里super.num代表父类中的num
        }
    }

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

    程序运行时，父类先加载进内存（方法区）；
    new对象时，堆内存中子父类的成员变量分别初始化（父类的成员变量存放在子类创建的对象中）；

    成员函数
    当子父类中出现成员函数一模一样时，会运行子类的函数，
    这种现象，称为覆盖操作，这是函数在子父类中的特性。
    函数两个特性：
        1.重载，在同一个类中；
        2.覆盖，在子类中；覆盖也称为重写或覆写（Override）。
    覆盖的注意事项：
    1.子类方法覆盖父类方法时，子类权限必须大于等于父类的权限（子类权限不足时无法覆盖）；
        父类中权限为private，这是不叫覆盖，因为父类中的方法子类根本无法调用；
    2.静态只能覆盖静态，或被静态覆盖（子父类中只有一个static时，不能覆盖或被覆盖）；
   
    什么时候使用覆盖操作？
    当对一个类进行子类的扩展时，子类需要保留父类的功能生命，
    但是要定义子类中该功能的特有内容时，就使用覆盖操作完成；
   

//成员函数
    /*
    当子父类中出现成员函数一模一样时，会运行子类的函数，
    这种现象，称为覆盖操作，这是函数在子父类中的特性。
    函数两个特性：
        1.重载，在同一个类中；
        2.覆盖，在子类中；覆盖也称为重写或覆写（overload）。
    覆盖的注意事项：
    1.子类方法覆盖父类方法时，子类权限必须大于等于父类的权限（子类权限不足时无法覆盖）；
        父类中权限为private，这是不叫覆盖，因为父类中的方法子类根本无法调用；
    2.静态只能覆盖静态，或被静态覆盖（子父类中只有一个static时，不能覆盖或被覆盖）；
    */
    class Fu
    {
        void show()
        {
            System.out.println("Fu show run");
        }
    }

    class Zi extends Fu
    {
        void call()
        {}
        void show()
        {
            System.out.println("Zi show run");
        }
    }
    class  ExtendsDemo3
    {
        public static void main(String[] args) 
        {
            //Zi z=new Zi();
            //z.show();//结果 Zi show run
            NewPhone p=new NewPhone();
            p.show();
        }
    }

    /*
    什么时候使用覆盖操作？
    当对一个类进行子类的扩展时，子类需要保留父类的功能生命，
    但是要定义子类中该功能的特有内容时，就使用覆盖操作完成；
    */

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

    //新版本的show()方法功能增多，通过覆盖来增加功能
    class NewPhone extends Phone
    {
        void show()//保留父类原有功能，定义子类特有内容
        {
            System.out.println("name");
            System.out.println("pic");
            super.show();//不需要重写代码，直接调用父类的方法
        }
    }

继承
    子父类中的构造函数的特点
    在子类构造对象时，发现，执行子类构造函数时，父类也运行了
    原因：在子类的构造函数中，第一行有一个默认的隐式语句，super()，调用的是父类中空参数的构造函数
                        如果父类构造函数有参数则使用super(参数)指定
    子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数；

    为什么子类实例化的时候要访问父类中的构造函数？
    因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容之前，
    要先看父类是如何对自己的内容进行初始化的。
    所以子类在构造对象时，必须访问父类中的构造函数。
    为了完成这个必须的动作，就在子类的构造函数中加入了super()语句。

    如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中的哪个构造函数，
    同时子类构造函数中如果使用了this调用了本类构造函数时，那么super()就没有了，因为super和this都只能定义在第一行，
    所以只能有一个，但是可以保证的是，子类中肯定会有其他的构造函数防伪父类的构造函数。
    注意：super语句必须要定义在子类构造函数的第一行；因为，父类的初始化动作要先完成。
   

class Fu
    {
        int num;
        Fu()
        {
            num=15;
            System.out.println("Fu Run");
        }
        Fu(int x)
        {
            System.out.println("Fu Run"+x);
        }
    }

    class Zi extends Fu
    {
        Zi()
        {
            //super();//调用的是父类中空参数的构造函数，如果父类构造函数则使用super(参数)指定
            System.out.println("Zi Run");
        }
        Zi(int x)
        {
            this();//该行代码运行时调用本类的空参数构造函数
            //super();
            //super(x);
            System.out.println("Zi Run"+x);
        }
    }

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

    /*
    class Demo //extends Object
    {
        Demo()
        {
            super();
            return();
        }
    }
    */

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

class Fu
    {
        Fu()
        {
            super();
            show();//子父类中都有show()方法，子类方法覆盖父类方法
            return;
        }

        void show()
        {
            System.out.println("fu show");
        }
    }
    class Zi extends Fu
    {
        int num = 8;
        Zi()
        {
            super();
            //通过super初始化父类内容时，子类的成员变量尚未显示初始化。等super()父类初始化完毕后，
            //才进行子类的成员变量显示初始化。

            System.out.println("zi cons run...."+num);
            return;
        }
        void show()
        {
            System.out.println("zi show..."+num);
        }
    }
    class ExtendsDemo5 
    {
        public static void main(String[] args) 
        {
            Zi z = new Zi();
            z.show();
        }
    }

抽象类
    特点：
    1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
        抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
    2，抽象类不可以被实例化。因为调用抽象方法没意义。
    3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
        否则，这个子类还是抽象类。
   
    问题
    1，抽象类中有构造函数吗？
    有，用于给子类对象进行初始化。
    2，抽象类可以不定义抽象方法吗？
    可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
    通常这个类中的方法有方法体，但是却没有内容。
       

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

    3，抽象关键字不可以和那些关键字共存?
    private 不行，私有化以后，子类不能对该方法覆写，故编译报错
    static    不行，static修饰的方法不需要对象，可直接使用类调用，但是抽象方法无意义
    final    不行，final修饰的方法不可覆盖，与abstract冲突

    4，抽象类和一般类的异同点。
    相同点：
        抽象类和一般类都是用来描述事物的，都在内部定了成员。
    不同：
        1，一般类有足够的信息描述事物。
           抽象类描述事物的信息有可能不足。
        2，一般类中不能定义抽象方法，只能定非抽象方法。
           抽象类中可定义抽象方法，同时也可以定义非抽象方法。
        3，一般类可以被实例化。
           抽象类不可以被实例化。

    5，抽象类一定是个父类吗？
    是的。因为需要子类覆盖其方法后才可以对子类实例化。
   

/*
    雇员示例
    要求：公司中程序员有姓名，工号，薪水，工作内容
    项目经理有姓名，工号，薪水，奖金，工作内容
    对给出需求进行数据建模

    分析：
    在这个问题领域中，先找出涉及的对象；
    通过名词提炼法：
        程序员：
            属性：姓名、工号、薪水
            行为：工作
        项目经理：
            属性：姓名、工号、薪水、奖金
            行为：工作

    程序员、经历之间不存在直接继承关系；但是，程序员和经理具有共性的内容；
    可以进行抽取，因为他们都是公司雇员

    将程序员和经理进行抽取，建立体系->雇员
    */
    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---");
        }
    }
    class AbstractTest 
    {
        public static void main(String[] args) 
        {
            Programmer p=new Programmer("张三","1001",999);
            Manager m=new Manager("李四","1002",9999,888);
            p.work();
            m.work();
        }
    }

final关键字
    final可以修饰类，方法，变量；
    final修饰的类不可以被继承；
    final修饰的方法不可以被覆盖；
    final修饰的变量是一个常量，只能被赋值一次；
    内部类只能访问final修饰的局部变量；
    为什么要用final修饰变量？
    其实在程序中如果一个数据时固定的，那么直接使用这个数据就可以了，
    但是这样阅读性差，所以为该数据起名，
    而且这个变量名称的值不能变化，所以加上final固定。

    写法规范：常量，所有字母都大写，多个单词中间用 _ 连接；
    例如 final double MY_PI=3.14;
   

class Fu
    {
        void method()
        {
            //调用了底层的系统资源；
        }
    }
    class Zi extends Fu
    {
        public static final double MY_PI=3.14;//public，全局变量;static修饰，类名可直接访问
        //static final int x=7;//使用final修饰的变量，不默认初始化为0，必须显示初始化
        void method()
        {
            int x=9;
            System.out.println(MY_PI);
        }
    }

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

接口
    格式：interface {}
    接口中的成员修饰符是固定的：
        成员常量 public static final，在不手动指定修饰符时，默认自动添加，但是可读性差
        成员函数 public abstract，在不手动指定修饰符时，默认自动添加，但是可读性差
        接口中的成员都是public的
实现 (implements)
    接口不能实例化，只能由实现了接口的字了并覆盖了接口中所有的抽象方法后，该子类才可以实例化
    否则，这个子类就是一个抽象类；

    多实现：
    在java中不直接支持多继承，因为会出现调用的不确定性；
    所以java将多结成机制进行了改良，在java中变成了多实现；
    一个类可以实现多个接口；
    一个类在继承另一个类的同时，还可以实现多个接口
    接口的出现避免了多继承的局限性;
    类与类之间是继承关系，类与接口之间是实现关系；
    接口与接口之间是继承关系，而且可以实现多继承；(与类的继承不同。主要是方法体的原因)

    接口的特点：
    1.接口是对外暴露的规则；
    2.接口是程序的功能扩展；
    3.接口的出现降低耦合性；
    4.接口可以用来多实现；
    接口与接口之间是继承关系，而且可以实现多继承；(与类的继承不同。主要是方法体的原因)
    一个类在继承另一个类的同时，还可以实现多个接口，接口的出现避免了多继承的局限性;
    接口与抽象类
    共性：都是不断抽取出来的抽象的概念
    区别：
        1.抽象类体现继承关系，一个类只能单继承；
             接口体现实现关系，一个类可以多实现；
        2.抽象类是继承，是“is a”关系,定义该体系的基本共性内容；
             接口是实现，是“like a”关系，定义体系的额外功能；
        3.抽象类中可以定义非抽象方法，供子类直接使用；
             接口的方法都是抽象的，接口中的成员都有固定修饰符；
   

interface Demo
   {
       public static final int NUM=4;

       public abstract void show1();
       public abstract void show2();
   }
   //类与类之间是继承关系，类与接口之间是实现关系
   /*
   接口不能实例化
   只能由实现了接口的字了并覆盖了接口中所有的抽象方法后，该子类才可以实例化
   否则，这个子类就是一个抽象类

   */
   class DemoImp1 implements Demo
   {
       public void show1()
       {}
       public void show2()
       {}
   }

   /*
   在java中不直接支持多继承，因为会出现调用的不确定性；
   所以java将多结成机制进行了改良，在java中变成了多实现；
   一个类可以实现多个接口；


   */
   interface A
   {
       public abstract void show();
   }

   interface Z
   {
       public abstract void show();
   }

   class Test implements A,Z //多实现
   {
       public void show()
       {
       }
   }

   /*
   一个类在继承另一个类的同时，还可以实现多个接口
   接口的出现避免了多继承的局限性
   */
   class Q
   {
       public void method()
       {}
   }
   class Test2 extends Q implements A,Z
   {
       public void show()
       {}
   }
   class InterfaceDemo
   {
       public static void main(String[] args)
       {
           DemoImp1 d=new DemoImp1();
           System.out.println(d.NUM);
           System.out.println(DemoImp1.NUM);
           System.out.println(Demo.NUM);
       }
   }

接口的应用
    1.定义规则及使用规则
    2.实现规则
    ※接口类型的引用都指向（接收）接口的子类对象
   

/*
    笔记本电脑使用
    为了扩展笔记本的功能，但日后出现什么功能设备不知道

    定义一个规则，只要日后出现的设备都符合这个规则即可；
    规则在Java中就是借口；
    */
    interface USB//暴露的规则
    {
        public void open();
        public void close();
    }


    class BookPC
    {
        public static void main(String[] args)
        {
            usbUSB(new UPan());//功能扩展了
            usbUSB(new UsbMouse());
        }

        //使用规则
        public static void usbUSB(USB u)//（多态性）接口类型的引用都指向（接收）借口的子类对象
        {
            u.open();
            u.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");
        }
    }

多态
    简单说：就是一个对象对应着不同类型；
    多态在代码中的体现，
        父类或者接口的引用指向其子类的对象；

    多态的好处：
        提高了代码的扩展性，前期定义的代码可以使用后期的内容；
    多态的弊端：
        前期定义的内容，不能使用（调用）后期子类的特有内容；
    多态的前提：
        1.必须有关系，继承，实现；
        2.要有覆盖；
    向上转型：1.为了提高扩展性；2.作用就是限制对特有功能的访问
    向下转型：向下转型的目的是为了是用子类中的特有方法
    ※注意：对于转型，自始至终都是子类对象在做类型的变化；
   

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) 
        {
            Animal a=new Cat();//自动类型提升，猫对象提升为动物类型，但是特有功能无法访问
                                                //作用就是限制对特有功能的访问
                                            //向上转型
            a.eat();

            //如果要是用具体动物猫的特有功能，可以将该对象进行向下转型
            //Cat c=(Cat)a;//向下转型的目的是为了是用子类中的特有方法
            method(new Cat());
            method(new Dog());
            method(new Pig());

            /*
            注意：对于转型，自始至终都是子类对象在做类型的变化；
            Animal a=new Animal();
            Cat c=(Cat)a;//ClassCastException，类型转换异常
            */
        }
        public static void method(Animal a)//Animal a=new Cat();
        {
            a.eat(); 
            if(a instanceof Cat)//用于判断对象的具体类型，只能用于引用数据类型判断
                                            //在向下转型前进行逻辑判断，增加程序的健壮性
            {
            Cat c=(Cat) a;
            c.catchMouse();
            }
            else if(a instanceof Dog)
            {
                Dog d=(Dog)a;
                d.lookHome();
            }
            else if(a instanceof Pig)
            {
                Pig p=(Pig)a;
                p.gongDi();
            }
        }
    }

    多态的特点
    Java中的多态仅对方法而言，成员变量还是使用的父类的成员变量
    成员函数：
        编译时：要查看引用变量所属的类中是否有所调用的成员；
        运行时：要查看对象所属的类中是否有所调用的成员；
    成员变量：
        编译时，参考引用型变量所属的类中是否有调用的成员变量；有，则编译通过；没有，编译失败；
        编译时，参考引用型变量所属的类中是否有调用的成员变量，并运行所属类中的成员变量；
        只看引用变量所属的类；
    静态函数
        编译时，参考引用型变量所属的类中是否有调用的静态方法；
        运行时，参考引用型变量所属的类中是否有调用的静态方法；
        静态方法，在类加载时就已存在，不需要通过对象绑定；调用引用所属类的方法
        对于静态方法， 是不需要对象的，直接通过类名调用即可；
   

class Fu
    {
        int num=3;
        void show()
        {
            System.out.println("fu show");
        }
        static void method()
        {
            System.out.println("fu static method");
        }
    }

    class Zi extends Fu
    {
        int num=4;
        void show()
        {
            System.out.println("zi show");
        }
        static void method()
        {
            System.out.println("fu static method");
        }
    }

    class  DuoTaiDemo3
    {
        public static void main(String[] args) 
        {
            Fu f=new Zi();
            f.show();//非静态方法，动态绑定到对象
            System.out.println(f.num);//Java中的多态仅对方法而言，成员变量还是使用的父类的成员变量
            f.method();//静态方法，在类加载时就已存在，不需要通过对象绑定；调用引用所属类的方法
        }
    }

   
    内部类
        将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
        访问特点：
            内部类可以直接访问外部类中的成员，包括私有成员；
            而外部类访问内部类中的成员必须要建立内部类的对象。

    一般用于类的设计
    分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，
    这时，被包含的事物定义为内部类来描述。
    通常的使用场景之一：
    当函数参数时借口类型时，而且接口中的方法不超过三个，
    可以用匿名内部类作为实际参数进行传递；
    ※注意：
    内部类定义在了外部类的成员位置，可以被成员修饰符修饰；
    如果内部类中定义了静态成员，该内部类也必须是静态的；
   

class Outer
    {
        private static int num=3;
        static class Inner    //内部类
        {
            void show()
            {
                System.out.println("show run..."+num);
            }
            static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的；
            {
                System.out.println("function 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();
            /*
            //直接访问外部类中的内部类的成员（内部类非静态）
            
            Outer.Inner in=new Outer().new Inner();
            in.show();
            //也可以写作
            Outer out-new Outer();
            Outer.Inner in=out.new Inner();
            in.show();
            */

            //如果内部类是静态的，那就相当于外部类
            Outer.Inner in=new Outer.Inner();
            in.show();

            //如果内部类是静态的，成员是静态的
            Outer.Inner.function();

        }
    }

    为什么内部类能直接访问外部类中的成员？
    因为内部类持有了外部类的引用；    外部类名.this；

    内部类可以存放在局部位置上；
    内部类在局部位置上只能访问局部中被final修饰的局部变量
    因为该局部变量相当于一个常量，它的生命周期超出方法运行的生命周期；

class Outer
    {
        int num=3;
        void method()
        {
            final int x=9;

            class Inner
            {
                void show()
                {
                    System.out.println("show..."+x);
                }
            }
            Inner in=new Inner();
            in.show();
        }
    }

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

    匿名内部类，就是内部类的简写形式（匿名对象是对象的简写形式）
        必须有前提：
        内部类必须继承或者实现一个外部类或者借口
    匿名内部类：其实就是一个匿名子类对象；
    格式：new 父类（接口名） (){子类内容};
   

abstract class Demo
    {
        abstract void show();
    }
    class Outer
    {
        int num=4;
        /*
        class Inner extends Demo
        {
            void show()
            {
                System.out.println("show..."+num);
            }
        }
        */
        public void method()
        {
            //new Inner().show();
            new Demo()
            {
                void show()
                {
                    System.out.println("show......"+num);
                }
            }.show();
        }
    }
    class InnerClassDemo4 
    {
        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 InnerClassDemo5 
    {
        class Inner
        {
        }
        public static void main(String[] args) 
        {
            //new Inner();// 错误: 无法从静态上下文中引用非静态 变量 this，静态方法中不允许存在this
            new Outer().method();
        }
        public void show()
        {
            new Inner();//在该方法中可以有this
        }
    }




    class Outer
    {
        void method()
        {
            //这里不能建立引用 Object obj=new Objcet();这里建立引用之后，向上转型，隐藏了子类中的特有方法
            new Object()//创建一个Object对象
            {
                public void show()
                {/*
                相当于
                class Inner extends Objcet
                {
                    public void show()
                    {};
                }
                */
                    System.out.println("show run");
                }
            }.show();

        }
    }

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

/*
    1.进入子类构造函数，super()
    2.调用父类构造函数，输出fu constructor code；
    3.show()，调用Zi.show()，输出 show...0;（尚未显示初始化）
    4.显示初始化
    5.执行构造代码块初始化，输出constructor code...9；
    6.执行子类构造函数中剩余语句；
    */
    class Fu
    {
        Fu()
        {
            System.out.println("fu constructor code");//第1个执行
            show();//Zi.show()；第2个，调用子类
        }
        void show()
        {
            System.out.println("hehe");
        }
    }

    class Zi extends Fu
    {
        int num=9;

        {//构造代码块并不是最早执行
            System.out.println("constructor code..."+num);//第3个
            num=10;
        }
        Zi()
        {
            //super();//第1个，调用父类
            //显示初始化
            System.out.println("zi constructor code..."+num);//第4个
        }
        void show()
        {
            System.out.println("show..."+num);
        }
    }

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