Java 封装，继承，多态

封装

• 封装：属性私有，get/set方法
• 关键字：private

Student类

package com.oop.demo4;

public class Student {
    private String name;
    private int age;
    private char sex;

    // get 获取这个数据
    public String getName() {
        return name;
    }

    // set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }

    public char getSex() {
        return sex;
    }

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

main方法

package com.oop.demo4;

public class Application {

    public static void main(String[] args) {
        Student student = new Student();

        student.setName("七七");
        student.setAge(999);
        student.setSex('女');

        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSex());
    }
}

封装的意义：

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

继承

• 继承：扩展的意思，子类(派生类)是父类(基类)的扩展，类和类的一种关系
• 关键字：extends
• 子类继承了父类就会有父类的所有非私有方法
• Java只有单继承，没有多继承
• 在Java中，所有的类都直接或间接的继承Object类

父类 Person类

package com.oop.demo5;

// 父类
public class Person {

    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

子类 Student类

package com.oop.demo5;

// 子类继承了父类，就会拥有父类的全部方法
// 子类
public class Student extends Person{
	
}

main

package com.oop.demo5;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say(); // 子类继承了父类的方法
        System.out.println(student.getMoney());
    }
}

多态

• 多态：即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多 （引用类型一般指父类或有关系的类）

多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

Person 父类

package com.oop.demo8;

public class Person {

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

Student 子类

package com.oop.demo8;

public class Student extends Person{

    public void run(){
        System.out.println("runrun");
    }

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

main

package com.oop.demo8;

public class Application {

    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        // 子类重写父类方法
        s1.run(); // runrun
        s2.run(); // runrun

        s1.eat();
        // 对象能执行那些方法，主要看对象左边的类型，跟右边关系不大
        //s2.eat();

    }
}