java重写、super关键字与this关键字、修饰符、多态

方法重写/覆盖

• 前提条件：继承或者实现
• 子父类中出现了一模一样的方法。修饰符、返回值、方法名、参数都必须一模一样
• 作用：方法升级

super关键字与this关键字

• super指向父类（调用父类方法或属性时候用到）
• this指向当前类（区分局部变量和成员变量同名）
• super() 调用父类构造方法
• this() 调用本类其他构造

修饰符

• 访问修饰符

• public、protected、默认修饰符、private

• 权限逐步降低，public的访问权限最大，private类型的访问权限最小

• 非访问修饰符

• static 静态（共享），不需要创建对象，直接类名调用

• final 常量、final 最终类（不能被继承，被绝育了）、final 方法（不能被重写）

• abstract 抽象

多态（Polymorphism）

• 概念：用父类的类型来接收子类的对象
• 先决条件：1.继承/接口实现 2.父类类型接收子类对象（实现扩展性）
• 优点：
• 扩展性强，解决了代码复用，降低类型耦合度
• 可以少定义变量，少些重复代码
• 案例：一个方法接受不同的子类类型
• 缺点：
• 不能使用子类特有方法
• 可以使用强转，转成对应子类类型，解决上述问题
• 使用方法:
• 父类 变量名1 = 子类对象;
• 子类 变量名2 = (子类)变量名1;
• 多态一般伴随重写使用
• 场景：
• public void driverCar(Car car) {
  car.run();
  }

public class AccessDemo {
    /**public：公共，任意都可以访问
     * protected：受保护，大部分情况给子类使用。子类都能访问，非子类出了包就不能访问
     * 默认修饰符：默认，只能在同包下访问
     * private：私有，只能本类访问
     **/
    public int publicField;
    protected int protectedField;
    int defaultField;
    private int privateField;

    public static void staticMethod(){
        System.out.println("aaaaa");
    }

    public static void main(String[] args) {
        staticMethod();
        AccessDemo.staticMethod();
        //可以省略AccessDemo a = new AccessDemo();
        //final将一个变量变为常量，防止别人修改
        final int a = 10;
    }
}

public class AccessSub2 extends AccessDemo {

    public void show(){
        //同一目录下能访问到publicField、protectedField、defaultField
        System.out.println(publicField);
        System.out.println(protectedField);
        System.out.println(defaultField);
    }
}

public class AccessSub extends AccessDemo {

    public void show(){
        //不同目录下只能访问到publicField、protectedField
        System.out.println(publicField);
        System.out.println(protectedField);
    }
}

public class Phone {
    //overload 重载
    //override 重写

    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
}

public class IPhone4s extends Phone{

    public IPhone4s(){
        //调用本类其他构造
        this(1);
    }
    public IPhone4s(int a){

    }
    public void siri(){
        System.out.println("hello siri");
    }
}

public class IPhone5 extends IPhone4s{

    public IPhone5(){
        //调用父类空参构造
        super();
        //super(1);
        System.out.println("IPhone5 构造");
    }

    /**方法重写：对父类的方法进行升级（改造）
     * @Override是注解，用来检测是否是重写
     * */
    @Override
    public void siri(){
        System.out.println("hello siri");
        //this指向当前类
        //super强行指向父类中方法
        //方法也存在就近原则，先在当前类中找，找不到去父类，再找不到去爷爷类
        //super解决方法重名问题
        super.siri();
        System.out.println("你好 siri");
    }
}

public class Card {
    public void getMoney(){
    }
}

public class CSCard extends Card{

    @Override
    public void getMoney(){
        System.out.println("欢迎光临长沙银行");
        System.out.println("谢谢惠顾");
    }

    public void newMethod(){
        System.out.println("子类中的新方法。。");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        ZhaoCard card1 = new ZhaoCard();
        JianCard card2 = new JianCard();
        NongCard card3 = new NongCard();
        CSCard card4 = new CSCard();

        atmGetMoney(card1);
        atmGetMoney(card2);
        atmGetMoney(card3);
        atmGetMoney(card4);

        //利用多态创建对象：父类类型接收子类对象（向上转型）
        //优点：同一个多态变量可以接收多个对象
        //只用一个变量card5就可以接收所有的子类对象
        Card card5 = new ZhaoCard();
        card5 = new JianCard();
        card5 = new NongCard();
        card5 = new CSCard();
        card5.getMoney();

        Card card6 = new CSCard();
        //多态的方式不能看到子类中特有的方法（父类中没有的）
        //可以利用强转来解决（向下转型）
        CSCard csCard = (CSCard)card6;
        csCard.newMethod();
    }

    /**支持多态的方法，接收Card和Card的所有子类
     * Card card = card1; ZhaoCard card1 = new ZhaoCard();
     * 父类类型接收子类对象
     * */
    public static void atmGetMoney(Card card){
        //加static只是为了在main方法中调用，和多态无关
        System.out.println("---------");
        card.getMoney();
        System.out.println("----------");
    }
}