【java基础--封装 继承 多态】

封装

属性私有private，get/set为用户提供获取和修改的方法

public class Student {
    //封装
    private int id;//学号
    private char sex;//性别

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setId(1);
        s1.setSex('男');
        System.out.println(s1.getId());//1
        System.out.println(s1.getSex());//男
    }
}

继承

类与类之间的关系，每个类只能直接继承一个父类

public class Person {
    public void say(){
        System.out.println("你好人类！！");
    }
}

public class Student extends Person{
}

public class text {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();//你好人类！！
    }
}

super

子类调用父类中的属性 方法（父类私有的无法继承）

public class Person {
    int id = 1;
    public void say(){
        System.out.println("你好人类！！");
    }
}

public class Student extends Person{
   public void talk(){
       super.say();
       System.out.println(super.id);
   }
}

public class text {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.talk();//你好人类！！ 1
    }
}

new对象 默认调用无参构造，子类的无参构造自动调用父类的无参构造
调用子类和父类的构造器均需在子类构造器的第一行

public class Person {
    public Person() {
        System.out.println("person无参构造器");
    }
}

public class Student extends Person{
    public Student() {
        //super();//隐藏代码：调用父类无参构造
        System.out.println("student无参构造器");
    }
}

public class text {
    public static void main(String[] args) {
        Student s1 = new Student();
    }
}

重写vs重载

重写是父子类之间方法的相同方法名相同参数列表的覆盖
重载是同一个类中相同方法名但参数列表不同

重写

public class Person {
    public void say(){
        System.out.println("你好人类！！");
    }
}

public class Student extends Person{
    @Override
    public void say() {
        System.out.println("你好学生！！");
    }
}

public class text {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();//你好学生！！
        Person p = new Person();
        p.say();//你好人类！！
        Person p1 = new Student();
        p1.say();//你好学生！！
    }
}

重载

public class HelloWorld {
    int id ;
    public HelloWorld() {
        System.out.println("无参构造");
    }

    public HelloWorld(int id) {
        this.id = id;
        System.out.println("有参构造");
    }

    public static void main(String[] args) {
        HelloWorld h = new HelloWorld();//无参构造
        HelloWorld h1 = new HelloWorld(1);//有参构造
        System.out.println(h);//base.HelloWorld@1b6d3586
        System.out.println(h1);//base.HelloWorld@4554617c
        System.out.println(h.id);//0
        System.out.println(h1.id);//1
    }
}

多态

多态存在的条件：
    有继承关系
    子类重写父类的方法
    父类引用指向子类对象

public class Person {
    public void say(){
        System.out.println("你好人类！！");
    }
}

public class Student extends Person{
    @Override
    public void say() {
        System.out.println("你好学生！！");
    }
    public void talk(){
        System.out.println("说话！！");
    }
}

public class text {
    public static void main(String[] args) {
       //父类引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        //对象执行哪些方法主要看对象左边的类型，与右边无关

        s1.say();//你好学生！！
        s2.say();//你好学生！！ 子类重写了父类的方法，执行子类
        s1.talk();//说话！！
        ((Student)s2).talk();//说话！！
        //父类引用的对象中没有子类中的方法，故需转型
    }
}