面向对象三大特性

封装

高内聚，低耦合

封装大多作用于属性

修饰符：private

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

get：获得这个数据

set：给这个数据设置值

Student.java

package OOP.Demo01;

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

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    //get 获取该数据的值
    public String getName(){
        return this.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;
    }
}

Application.java

package OOP.Demo01;

public class Application {
    public static void main(String[] args) {
       Student s1 = new Student();
       String name = s1.getName();

       s1.setName("夏洛特");
        System.out.println(s1.getName());

        s1.setAge(666);
        System.out.println(s1.getAge());

    }

}

封装的意义

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

继承

继承的本质是对某一批类的抽象

extends：拓展

子类继承父类就会拥有父类的全部方法，前提是修饰符为public

在java中，所有的类都默认直接或间接继承Object类

Java中类只有单继承，没有多继承

Student.java

package OOP.Demo02;

public class Student extends Person{
}

Person.java

package OOP.Demo02;

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

    public int getMoney() {
        return money;
    }

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

Application.java

package OOP.Demo02;

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

    }
}

super详解

Student.java

package OOP.Demo02;

public class Student extends Person{
    private String name = "ALEN";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

Person.java

package OOP.Demo02;

public class Student extends Person{
    private String name = "ALEN";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

Application.java

package OOP.Demo02;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.test("耶格尔");
    }
}

调用父类的构造器，必须在子类构造器的第一行

super注意点

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

与this的区别

1.代表对象的不同：

this：本身调用者这个对象

super：代表父类对象的调用

2.前提：
this：没有继承也可以使用

super：只能在继承条件下使用

3.构造方法

this：本类的构造方法

super：父类的构造方法

重写

重写的前提是需要有继承关系，子类重写父类

重写都是方法的重写，和属性无关

静态方法：方法的调用只和左边定义的数据有关

非静态：重写

特点

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

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

为什么需要重写

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

操作：Alt + insert : override

多态

Person.java

package OOP.Demo03;

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

Student.java

package OOP.Demo03;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("跑快点");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

Application.java

package OOP.Demo03;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
         //new Student()
         //new Person()

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

        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        ((Student)s2).eat();//s2.eat();需要强制转换，因为s2是Person类的
        s1.eat();

    }
}

多态的注意事项

• 多态是方法的多态，属性没有多态

• 父类和子类有联系，否则类型转换异常 ClassCastException!

• 存在条件：

  继承关系

  方法需要重写 ，若两个类中都有该方法，那就要执行子类中的；只有一个的话，就要看前面的数据类型（对象）

  父类引用指向子类对象

• 不能被重写的方法：

  static:静态方法，属于类，不属于实例

  final：常量

  private：私有方法