Day09-封装，继承，多态

封装

程序设计应当：高内聚，低耦合

做法：属性私有，get/set

private

public class Main{
    public static void main(String[] args){
        Student s1= new Student();
        s1.setName("chen");
        System.out.println(s1.getName());
        //将类中的变量变为私有变量，则只能通过set/get来进行赋值和获值
    }
}
public class Student{
    private String name;
    private int age;
    public String getName(){
		return this.name;
    }
    public void setName(String name){
        this.name =name;
        //set/get的方式可以对设置的值进行一些判断，增加安全性
    }
}

特点

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

子类可以拥有父类的所有公共方法，属性一般通过get/set来调用

特点

1. Java类中只有单继承
2. 所有类默认继承object类
3. 私有的东西无法被继承

public class Main{
    public static void main(String[] args){
        Student s1 = new Student();
        s1.say();	//继承了person的方法
        System.out.println(s1.getMoney());
    }
}
public class Person{
    private int money =10_0000_0000;
    public void say(){
        System.out.println("Hi");
    }
    public void String setMoney(int money){
        this.money = money;
    }
    public  int getMoney(){
        return this.money = money;
    }
}
public class Student extends Person{
    
} 

super

public class Main{
    public static void main(String[] args){
        Student s1 = new Student();
        s1.say();	//继承了person的方法
        System.out.println(s1.getMoney());
    }
}
public class Person{
    private int money =10_0000_0000;
    public Person(){
        System.out.println("Person无参构造器正在执行")
    }
    public void say(){
        System.out.println("Hi");
    }
}
public class Student extends Person{
    public Student(){
        //隐藏代码super();
        super();	//调用了父类构造器
        System.out.println("Student无参构造器执行了")
    }
    public void say(){
        System.out.println("Student say hi");
        say();		//类的公共方法可以直接调用
        this.say();	//this关键字可以调用类中的属性或者方法
        super.say();//在继承了父类后，可以通过super来调用父类的方法或者属性
    }
} 

重点

1. super调用父类的构造方法，必须在子类构造方法中的第一行，否则报错
2. super只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造器

方法重写

1. 私有方法不能被重写
2. 静态方法无法被重写
3. 子类重写父类方法

• 方法名必须相同
• 参数列表必须相同

4. 抛出的异常：范围可以被缩小，但不能扩大

public class Main{
    public static void main(String[] args){
        A a =new B();
        a.say();	//输出hi
        a.test();	//输出B，	方法被重写
        B b =new B();
        b.say();	//输出B，hi  静态方法无法被重写，所以此时只跟左边有关
        b.test();	//输出B
    }
}
public class A{
    public static void say(){
        System.out.println("hi");
    }
    public void test(){
        System.out.println("A");
    }
}
public class B extends A{
    public static void say(){
        System.out.println("B,hi");
    }
    public void test(){
        System.out.println("B");
    }
}

多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式

public class Main{
    public static void main(String[] args){
        A s1 = new B();
        B s2 = new B();
        Object s3 = new B();
        s1.test();
        s2.test();//两者均为B，当父类的方法被子类重写时，将会调用子类的方法
        s1.haha();//引用时A，所以可以调用A中独有的方法
        s2.haha();//错误，没有该方法
        s1.heihei();//错误
        ((B)s1).heihei();//强制转换，从父类转换为子类
    }
}
public class A{
    public static void say(){
        System.out.println("hi");
    }
    public void test(){
        System.out.println("A");
    }
    public void haha(){
        System.out.println("哈哈");
    }
}
public class B extends A{
    public static void say(){
        System.out.println("hi");
    }
    public void test(){
        System.out.println("A");
    }
    public void heihei(){
        System.out.println("嘿嘿");
    }
}

类型转换

父类与子类存在部分方法不同，当引用对象不同时，可以同过强制转换来使父类对象可以调用子类方法

public class Main{
    public static void main(String[] args){
        A a = new B();
        B b = new B();
        ((B)a).go();
        b.say();	//子类调用父类独有的方法可以不用强制转换，但可能会丢失子类的方法
    }
}
public class A{
    public void say(){
        System.out.println("A");
    }
}
public class B extends A{
    public void go(){
        System.out.println("B");
    }
}

优点

方便方法的调用，减少重复代码