封装、继承、多态

一、封装

封装的意义

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

实例：

Student.java文件

//类 private:私有的
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 -->Getter and Setter -->自动生成get set方法

    public int getAge() {
        return age;
    }

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

调用文件

import oop.demo04.Student;

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

        student.setName("111");
        System.out.println(student.getName());

        student.setAge(70);
        System.out.println(student.getAge());

    }
}

二、继承

1. 类的继承和调用

Person类

//Person 人：父类，基类
public class Person {

    //public    公共的
    //protected 受保护的
    //default   默认的
    //private   私有的
    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类

//Student is 人 ：派生类，子类
// 子类继承父类，就会拥有父类的全部方法
public class Student extends Person{
    //Ctrl + H --->显示继承树

}

调用子类中的方法

import oop.demo05.Student;
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();
    }
}

2. Object类

在Java中所有的类都默认直接或间接继承object类

3. super

super注意点：

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

super VS this：

• 代表的对象不同：
  • this：本身调用着这个对象
  • super：代表父类对象的应用
• 前提
  • this：没有继承也可以使用
  • super：只能在继承条件才可以使用
• 构造方法
  • this()：本类的构造
  • super()：父类的构造

实例：
子类：

//Student is 人 ：派生类，子类
// 子类继承父类，就会拥有父类的全部方法
public class Student extends Person{
    public Student() {
        //隐藏代码：调用了父类的无参构造
        super(); //调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "222";

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

    public void test1() {
        print();        //Student
        this.print();   //Student
        super.print();  //Person
    }

    public void test(String name) {
        System.out.println(name);       //333
        System.out.println(this.name);  //222
        System.out.println(super.name); //111
    }
}

父类：

//Person 人：父类，基类
public class Person {

    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name = "111";

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

    //私有的东西无法被继承
    //private void print(){
    //    System.out.println("Person");
    //}
}

应用

import oop.demo05.Student;

public class Application{
    public static void main(String[] args) {
        Student student = new Student();
        //student.test("333");
        //student.test1();
    }
}

4. 重写

静态方法不叫重写，例如：

/*调用*/
import oop.demo05.A;
import oop.demo05.B;

public class Application{
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test(); //A

        //父类的引用指向了子类
        B b = new A();
        b.test(); //B
    }
}
/*子类A*/
public class A extends B{
    public static void test() {
        System.out.println("A=>test()");
    }
}
/*父类B*/
//重写都是方法的重写，和属性无关
public class B {
    public static void test() {
        System.out.println("B=>test()");
    }
}

静态的方法和非静态的方法区别很大

• 静态方法：方法的调用只和左边，定义的数据类型有关
• 非静态方法：重写

重写实例

/*调用*/
import oop.demo05.A;
import oop.demo05.B;

public class Application{
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test(); //A

        //父类的引用指向了子类
        B b = new A();
        b.test(); //A
    }
}
/*子类A*/
public class A extends B{
    //Override  重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}
/*父类B*/
//重写都是方法的重写，和属性无关
public class B {
    public void test() {
        System.out.println("B=>test()");
    }
}

重写总结

需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public>protected>default>private
4. 抛出的异常：可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

重写子类的方法和父类的必须一致，方法体不同

为什么重写：

1. 父类的功能子类不一定需要，或者不一定满足

Alt + Insert --> override;

三、多态

多态

Application.java文件

import oop.demo06.Person;
import oop.demo06.Student;

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

        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了：父类的引用指向了子类

        //Student 能调用的方法都是自己或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边的关系不大！
        s2.run(); //子类重写了父类的方法，执行子类的方法
        s1.run();

        //s2.eat(); //不能执行
        ((Student) s2).eat();//强制类型转换
        s1.eat();
    }
}

Student.java文件

public class Student extends Person {

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

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

Person.java文件

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

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常！ ClassCastException！
3. 存在的条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();

不能重写的方法:

1. static 方法，属于类，不属于实例
2. final 常量
3. private 方法 //私有的

instanceof和类型转换

instanceof

/*Application.java*/
public class Application{
    public static void main(String[] args) {

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        System.out.println(object instanceof Student);  // true
        System.out.println(object instanceof Person);   // true
        System.out.println(object instanceof Object);   // true
        System.out.println(object instanceof Teacher);  // false
        System.out.println(object instanceof String);   // false

    }
}
/*Person.java*/
public class Person {
    public void run (){
        System.out.println("run");
    }
}
/*Student.java*/
public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}
/*Teacher.java*/
public class Teacher extends Person {
}

类型转换

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型；
3. 把父类转换为子类，乡下转型，强制转换
4. 方便方法的调用，减少重复的代码！

/*Application.java*/
public class Application{
    public static void main(String[] args) {
        //类型之间的转化：父     子

        //高                低
        Person obj = new Student();
        //obj.go();//编辑报错，没有该方法
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student = (Student) obj;
        student.go();
        //等价于
        ((Student) obj).go();


        //子类转换为父类，可能丢失自己的本来的一些方法
        Student stu = new Student();
        stu.go();
        Person person = stu;
        //person.go(); //编辑报错，没有该方法
        ((Student) person).go();
    }
}
/*Person.java*/
public class Person {
    public void run (){
        System.out.println("run");
    }
}
/*Student.java*/
public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}
/*Teacher.java*/
public class Teacher extends Person {
}