封装 继承和多态

封装继承和多态

封装

我们在设计程序时，讲究六个字，高内聚，低耦合
封装就是我们对数据进行隐藏，多用于来封装属性，封装方法较少。

记住封装的核心，就是私有（private）

令属性为私有后我们调用不了类里面的属性，所以我们设置一些get方法和set方法来操作私有的属性

get方法，set方法

---

public int getAge(){
	return age;
}

public void setAge(int age){
	this.age = age;
}

---

具体代码应用

设置一个学生类，令其定义的属性私有
在类里面设置get set方法，使主函数可以调用类里面私有的属性

package com.oop.demo03;

public class Student {

    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供一些可以操作这些属性的方法
    //提供一些public的get和set方法

    //get方法 得到这个属性
    public String getName(){
        return this.name;
    }

    //set 为属性设置一些值
    public void setName(String name){
        this.name=name;
    }

    //alt+insert 自动生成get set方法
    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>150 || age<0){//不合法的
            this.age=3;
        }
        else {
            this.age = age;
        }
    }
}

设置一个应用类，用来操作学生类

import com.oop.demo03.Student;

public class Application {
    public static void main(String[] args) {

        Student s1 = new Student();

        s1.setName("小张");
        System.out.println(s1.getName());

        s1.setAge(999);//不合法的年龄
        System.out.println(s1.getAge());

    }

}

在idea里可以使用快捷键alt+insert快速生成get set 方法

继承

• 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
• java中只能单继承，一个父亲可以有多个儿子，但是一个儿子只能有一个父亲
• 子类可以继承父类的全部方法，私有不可以被继承。

关于生活中的继承
人类（Person） //父类
- 老师类（Teacher） //子类，派生类
- 学生类（Student） //子类，派生类

public
protect
default
private

继承格式

class 父类 {
}

class 子类 extends 父类 {
}

代码举例

创造一个Person类

public class Person {



    public int money = 1_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }

}

创造一个Student类继承Person类

public class Student extends Person {
}

在Application中进行测试

public class Application {
    public static void main(String[] args) {

        //因为Student继承了父类，所以可以直接使用父类的方法
        Student student = new Student();
        student.say();
        System.out.println(student.money);

    }
}

代码结果证明，子类可以完全继承父类的方法

super方法

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

父类

public class Person {

    protected String name =  "小张";

}

子类

public class Student extends Person {
    private String name = "小小张";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);

    }

}

主函数

public class Application {
    public static void main(String[] args) {

        Student student = new Student();

        student.test("张瑞");
    }
}

方法重写

重写可以理解为子类想要改变父类原来的方法，所以重写了方法
重写：

1. 需要有继承关系,子类重写父类的方法
2. 方法名必须相同
3. 参数列表必须相同
4. 抛出异常的方位可以缩小不能扩大
5. 方法体不同

public class B {

    public void test(){
        System.out.println("B=>test()");
    }
}

public class A extends B{

    @Override
    public void test() {
        System.out.println("A=>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        B b = new A();
        b.test();
    }
}

多态

多态就是一个方法可以根据发送对象的不同而采取多种不同的行为的方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象
• 注意:多态是方法的多态，属性没有多态性。

多态注意事项:

1.多态是方法的多态，属性没有多态

2.父类和子类，有联系类型转换异常! ClassCastException !

3.存在条件:继承关系， 方法需要重写，父类引用指向子类对象! Father f1 = new Son();

下面三种类型不可以重写，没有多态：

1. static方法，属于类，它不属于实例
2. final 常量;
3. private方法;

父类

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

}

子类

public class Student extends Person {
    @Override
    public void rnu() {
        System.out.println("son");
    }

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

测试

public class Application {
    public static void main(String[] args) {


        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        s1.rnu();
        s2.rnu();

        s1.eat();

    }
}

写在最后
最短的距离是手到嘴，最长的距离是说到做