【Java基础-面向对象下（2/2）】

• abstract关键字
• 接口interface
• 内部类

1、abstract：抽象的
2、abstract可以用来修饰的结构：类、方法
3、abstract修饰类：抽象类
> 此类不能实例化
> 抽象类中一定有构造器，便于子类实例化时候调用（涉及：子类对象实例化的全过程）
> 开发中都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4、abstract修饰方法：抽象方法
> 抽象方法只要方法的声明，没有方法体
> 包含抽象方法的类，一定是一个抽象类，反之，抽象类不一定有抽象方法。
> 若子类重写了父类中所以的抽象方法后 ，此子类方可实例化。
若子类没有重写了父类中所以的抽象方法后 ，则意味此子类也是一个抽象类，需要使用abstract修饰子类。
5、abstract使用上的注意点：
① abstract不能修饰：属性、构造器、代码块等结构。
② abstract不能用来修饰私有（private）方法 、 静态（static）方法 、final的方法、final的类
(子类看不到无法重写) （无法覆盖静态方法，只是隐藏） （final的不可修改，所以无法重写）

			//一旦类被abstract修饰，就不可实例化
          // AbstractPerson abstractPerson = new AbstractPerson();
//----------------------  类  ----------------------------
abstract class Creature{

    public abstract void breath();

}
abstract class AbstractPerson extends Creature{
    String name;
    int age;

    public AbstractPerson() {
    }

    public AbstractPerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

//    public void eat(){
//        System.out.println("人吃饭");
//    }

    //抽象方法
    public abstract void eat();

    public void walk(){
        System.out.println("人走路");
    }
}

接口的使用一：
1、接口使用interface来定义
2、在Java中，接口和类是并列的两个结构
3、如何定义接口：定义接口中的成员
3.1 JDK7及以前：只能定义全局常量和抽象方法
>全局常量:public static final的，但是书写时，可以省略不写
>抽象方法：public abstract的
3.2 JDK8：除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法（略）
4、接口中不能定义构造器！意味着接口不可以实例化
5、Java开发中，接口通过让类去实现（implements）的方式来使用。
如果实现类覆盖了接口中的所以抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所以的抽象方法，则此实现类仍为一个抽象类。
6、Java类可以实现多个接口 ----> 弥补了Java单继承性的局限性

            格式：class AA extends BB implements CC,DD,EE{

            }

            A接口也可以extends B接口作为B接口的子接口。

7、接口与接口直接可以继承，而且可以多继承
8、接口的具体使用，体现多态性
9、接口，实际上可以看做是一种规范

				System.out.println(Flyable.MAX_SPEED);
                System.out.println(Flyable.MID_SPEED); //静态的

//              Flyable.MID_SPEED = 2; //final的
                Plan plan = new Plan();
                plan.fly();
                plan.stop();

        

        Computer computer = new Computer();

        //1、创建了接口非匿名实现类的非匿名对象
        Flash flash = new Flash();
        computer.transferDate(flash);           //接口也满足多态性（USB usb） ---> (Flash)

        //2、创建了接口的非匿名实现类的匿名对象
        computer.transferDate(new Printer());

        //3、创建了接口的匿名实现类的非匿名对象
        USB usb = new USB() {
            @Override
            public void start() {
                System.out.println("接口的匿名实现类的非匿名对象开始");
            }

            @Override
            public void stop() {
                System.out.println("接口的匿名实现类的非匿名对象结束");
            }

            @Override
            public void work() {
                System.out.println("接口的匿名实现类的非匿名对象工作");
            }
        };

            computer.transferDate(usb);

        //4、创建接口的匿名实现类的匿名对象
            computer.transferDate(new USB(){
                @Override
                public void start() {
                    System.out.println("接口的匿名实现类的匿名对象开始");
                }

                @Override
                public void stop() {
                    System.out.println("接口的匿名实现类的匿名对象结束");
                }

                @Override
                public void work() {
                    System.out.println("接口的匿名实现类的匿名对象工作");
                }
            });



            //JDK8新特性：接口中定义的静态方法、默认方法的使用
            SubClass subClass = new SubClass();

            //默认方法
            subClass.method3(); //默认方法通过实现类“对象.方法”调用。

            subClass.method2(); //如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写后的方法。

            subClass.method4();//SuperClass_Method4 , 如果子类（或实现类）继承的父类和实现的接口中，声明了同名同参的方法，
                                //那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参的方法。 --> 类优先原则

            
            SuperClassB superClassB = new SuperClassB();
            superClassB.method3();



            //静态方法
            //subClass.method1(); //编译不通过
            //SubClass.method1(); //编译不通过
            CompareA.method1(); //通过。 “接口.方法”调用。接口中的静态方法是“接口的方法”，不是实现类、实现类对象的方法。
//---------------------------  接口  --------------------------------
                                           //接口--->Flyable接口
interface Flyable{

    //全局常量
    public static final int MAX_SPEED = 7900;
    int MID_SPEED = 1; //public static final可以省略不行，接口属性默认为public的全局常量。

    //抽象方法
     public abstract void fly();

     void stop();//public abstract可以省略不写，接口方法默认为public的抽象类。


}


                                        //Plan类 ----> 实现Flyable接口
class Plan implements Flyable{

    @Override
    public void fly() {
        System.out.println("通过引擎起飞");
    }

    @Override
    public void stop() {
        System.out.println("驾驶员减速停止");
    }
}



                                                //AA接口
interface AA{
    void meath1();
}

                                                //BB接口
interface BB{
    void meath2();
}

                                        //CC接口 --->实现AA，BB接口

interface CC extends AA,BB{ //接口和接口之间可以多继承
 //加载了AA，BB中的属性和抽象方法
}



                                                //USB接口
interface USB{
    //常量：定义了长、宽、最大、最小的传输速度等

    //抽象方法
    void start();
    void stop();
    void work();
}



                                        //Flash类 ---> 实现USB类
class Flash implements USB{
    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }

    @Override
    public void work() {
        System.out.println("U盘传输数据");
    }
}



                                        //Printer类 ---> 实现USB类
class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机关闭工作");
    }

    @Override
    public void work() {
        System.out.println("打印机打印文章");
    }
}



                                                //Computer类
class Computer{
    public void transferDate(USB usb){
        usb.start();
        usb.work();
        usb.stop();
    }
}



                                        //JDK8新特性----接口CompareA

interface CompareA{
    //静态方法
    public static void method1(){           //接口默认为public的，可以省略public
        System.out.println("method1");
    }

    //默认方法
    public default void method2(){
        System.out.println("method2");
    }

    default void method3(){
        System.out.println("method3");
    }

    default void method4(){
        System.out.println("method4");
    }

}


                            //SubClass ----> 类SuperClass的子类、接口CompareA的实现类
class SubClass extends SuperClass implements CompareA{
    @Override
    public void method2() {
        System.out.println("SubClass_Method2");
    }

    public void myMethod(){

        //如何在子类（或实现类）的方法中，调用父类、接口中被重写的方法。
        method2();//调用自己定义的重写的方法
        super.method4();//调用父类声明的

        //调用接口中的默认方法
        CompareA.super.method2();
    }
}



                                            //SuperClass类
class SuperClass{
    public void method4(){
        System.out.println("SuperClass_Method4");
    }
}


                                            //接口CompareB
interface CompareB{
    default void method3(){
        System.out.println("CompareB_Method3");
    }
}


                                //SuperClassB类--->实现接口CompareA、CompareB
class SuperClassB implements CompareA,CompareB{

    @Override
    public void method3() {
        System.out.println("SuperClassB_Method3");
    }
}
            

类的内部成员之五：内部类

        1、Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

        2、内部类分类：成员内部类(静态、非静态) vs 局部内部类（方法内、代码块内、构造器内）

        3、成员内部类：
                一方面，做完外部类的成员
                    > 调用外部类的结构
                    > 可以用static修饰
                    > 可以被4种不同的权限修饰

                另一方面，做完一个类：
                    > 类内可以定义属性、方法、构造器等
                    > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承。
                    > 可以被abstract修饰

        4、关注如下3个问题
            4.1 如何实例化成员内部类的对象
            4.2 如果在成员内部类中区分调用外部类的结构
            4.3 开发中局部内部类的使用 《见类InnerClass2》

			//创建dog实例（静态成员内部类）
            InnerClassPerson.dog dog = new InnerClassPerson.dog();
            dog.show();
            //创建Bird实例（非静态成员内部类）
            InnerClassPerson person = new InnerClassPerson();
            InnerClassPerson.Bird bird = person.new Bird(); //非静态的，需要用外部类的对象调用内部类的构造器。
            bird.sing();
            bird.display("黄鹂");

           
//--------------------  类  ---------------------------------------
                                    //内部类---InnerClassPerson类
class InnerClassPerson{
    String name = "小明";
    int age;

    public void eat(){
        System.out.println("人吃饭");
    }
    //成员内部类
    //静态成员内部类
    static class dog{
        String name;
        int age;

        public void show(){
            System.out.println("卡拉是条狗");
            //eat(); 静态内部类整体是静态的，所以静态内部类的方法也只能调用静态的。

        }
    }
    //非静态成员内部类
        final class Bird{
        String name = "杜鹃";

        public Bird() {
        }

        public void sing(){
            System.out.println("我是一只小小鸟");

            //调用外部类的结构
            InnerClassPerson.this.eat();//调用外部类的非静态属性 ：InnerClassPerson.this（外部类的对象）
            //eat();    //可以直接写eat(),省略了InnerClassPerson.this.
        }

        public void display(String name){
            System.out.println(name);//形参的属性
            System.out.println(this.name);//内部类自己的属性
            System.out.println(InnerClassPerson.this.name);//外部类的属性
        }
    }

    //局部内部类（构造器）
      public InnerClassPerson(){
        class AA{

        }
      }
    //局部内部类（代码块）
    {
        class BB{

        }
    }
    //局部内部类（方法）
    public void method(){
        class CC{

        }
    }
}

                            //局部内部类的使用---InnerClass2类
class InnerClass2{

    //开发中很少见
    public void method(){
        //局部类
        class AA{

        }
    }

    //返回一个实现了Comparable接口的实现类的对象
    public Comparable getComparable(){

        //方式一：
//        class MyComparable implements Comparable{
//            @Override
//            public int compareTo(Object o) {
//                return 0;
//            }
//        }
//        return new MyComparable();

        //方式二：
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }

}

                                            //InnerClass3类
class InnerClass3{

    public void method(){

        int num = 10;

        class AA{

            public void show(){
                    //num = 20; 调用内部类所在方法的局部变量，这个变量就会变成final的。
                System.out.println(num);
            }
        }
    }

}