木舟0基础学习Java的第九天(面向对象，final，多态，抽象类，接口)

面向对象OOP

final（最终的）：用final修饰的 所以变量名必须大写

修饰类：类不能被继承

修饰变量：变量就变成了常量只能被赋值一次

修饰方法：方法不能被重写

多态（polymorphic）

多态的前提：

                  1.有继承关系

                  2.有方法重写//在多态中编译时会检查父类中是否有被重新的方法

                  3.有父类的引用指向子类对象

示例代码：

public class Animal {//父类
    String colour="黑色";
    public void eat(){
        System.out.println(colour+"动物吃饭");
    }
}

public class Cat extends Animal{//继承父类
    String colour="白色";
    public void eat(){//重写父类eat()方法
        System.out.println(colour+"猫吃鱼");
    }
}

public class Demo {
    public static void main(String[] args){
        Animal c=new Cat();//父类的引用指向子类对象
        c.eat();
    }
}

成员变量：编译看父类 运行看父类

成员方法：编译看父类 运行看子类（动态绑定）

静态方法：编译看父类 运行看父类 （算不上重写 访问的还是父类 当成普通类就好）

多态的好处：提高代码的维护性（继承保证）提高代码的拓展性（多态保证）

多态的弊端：在多态当中父类的引用不能调用子类特有的属性和方法（解决方法强转：向上转型，向下转型）

向下转型：

public class Person {
    String name;
     public void eat(){
         System.out.println("吃饭");
     }
     public void drink(){
         System.out.println("喝水");
     }
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class Muzhou extends Person{
    public void study(){
        System.out.println(name+"学习");
    }
    public void playGame(){
        System.out.println(name+"打游戏");
    }
    public void eat(){
        System.out.println(name+"吃饭");
    }
    public void drink(){
        System.out.println(name+"喝水");
    }
    public void sleep(){
        System.out.println(name+"睡觉");
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p=new Muzhou();
        p.name="木舟";
        //多态中 成员方法 编译看父类 运行看子类
        p.eat();//木舟吃饭
        p.drink();//木舟喝水
        p.sleep();//木舟睡觉
        //p.study();//报错 多态当中父类的引用不能调用子类特有的方法
        //p.playGame();//报错 多态当中父类的引用不能调用子类特有的方法
        Muzhou m=(Muzhou)p;//向下转型
        m.study();//木舟学习
        m.playGame();//木舟打游戏
    }
}

抽象类（abstract）：

抽象类特点：抽象类和抽象方法 必须用abstract关键字修饰

抽象类的成员特点：

                              1.成员变量:（既可以是变量也可以是常量）abstract 只能修饰类或者方法 不能                                                     修饰成员变量

                              2.构造方法：用于子类访问父类的初始化

                              3.成员方法：既可以是抽象的（强制要求子类做的事情）也可以是非抽象的                                                           (子类继承的事情)【一般开发中抽象类只写抽象方法】

抽象类不一定有抽象方法 有抽象方法的类一定是抽象类或者是接口

抽象类中可以没有抽象方法 但是没有意义 与抽象类的初衷有冲突

抽象方法没有实现 也就是说没有{}

抽象类不能被实例化 只能用多态的方式去实例化 （抽象类多态）子类实例化需要向下转型

抽象类的子类 要么是抽象类 要么重写抽象类中的所有抽象方法

抽象类中提供了一个标准 强制子类重写抽象方法

抽象类中可以有普通成员方法

abstract 不能与 static final private共存

static

被abstract修饰的方法没有方法体 没有具体实现方法

被static修饰的可以用类名.调用 但是类名.调用抽象方法没有意义

final

被abstracrt修饰的方法强制子类重写

被final修饰的不让子类重写 所以它俩矛盾

private

被abstract修饰是为了让子类看到并强制重写

被private修饰是不让子类访问 所以它俩也矛盾

接口（interface）

接口中的方法全部都是抽象的

接口写法：interface 接口名{}

实现接口：

public interface Inter {
    abstract void print();
}

public class Demo implements Inter{//用 implements 实现接口
    @Override
    public void print() {
        System.out.println("print");
    }
}

接口也不能被实例化 只能用多态的方式去实例化

接口的子类可以是抽象类 不能实例化 需要抽象类的子类 用多态的方法才能实例化

public interface Inter {
    public  void print();//会隐式自动加上 abstract
    int a=10;//接口里定义的变量都会变成常量 底层会自动加上public static final
    //一般接口中很少申明变量
}