【Java 面向对象三大特性】

封装

1. 通俗理解：将某些东西进行隐藏，然后提供相应的方式进行获取；
2. 封装的好处：提高代码的安全性；
3. 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
4. 低耦合：仅对外暴露少量的方法用于使用；
5. 隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性、可维护性；通俗的说，把该隐藏的隐藏起来，该暴露
   的暴露出来，这就是封装性的设计思想；

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 15:23:04
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person4 {
    private String name;
    private int age = -1;

    //对应的set和get方法
    public void setName(String name) {
        this.name = name;
    }
    //年龄初始化时，如果大于150或小于等于0的年龄，则为默认值-1，否则赋值
    public void setAge(int age) {
        if (age > 150 || age <= 0){
            return;
        }
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 15:40:37
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test05 {
    public static void main(String[] args) {
        Person4 p4 = new Person4();
        p4.setName("sqlboy");
        p4.setAge(250);
        System.out.println(p4.getAge());//-1
        p4.setAge(25);
        System.out.println(p4.getAge());//25
    }
}

• 总结
  • 将属性私有化，被private修饰，加入权限修饰符，一旦加入了权限修饰符，其他人就不可以随意的获取这个属性
  • 提供public修饰的方法让别人来访问/使用
  • 即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们在方法中可以加入 限制条件

继承

1. 子类继承父类一定在合理的范围进行继承的，子类 extends 父类；
2. 父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式，可以间接调用；
3. 一个父类可以有多个子类，一个子类只能有一个直接父类，但是可以间接的继承自其它类，因为继承具有传递性；
4. 继承的好处：提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了；便于代码的扩展；为了以后多态的使用。是多态的前提
5. 方法的重写：发生在子类和父类中，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写；重写的方法，子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致；
6. super：指的是父类的，可以修饰属性和方法
7. 在子类的方法中，可以通过 super.属性 super.方法 的方式，显示的去调用父类提供的属性和方法。在通常情况下，super.可以省略不写；在特殊情况下，当子类和父类的属性或方法重名时，你要想使用父类的属性，必须加上修饰符super.，只能通过super.属性来调用；
8. super修饰构造器：所有构造器的第一行默认情况下都有super()，但是一旦你的构造器中显示的使用super调用了父类构造器，那么这个super()就不会给你默认分配了；如果构造器中没有显示的调用父类构造器的话，那么第一行都有super()，可以省略不写；
9. super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存；因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行；

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 15:51:41
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person5 {
    private String name;
    int age;

    //补全缺省的构造方法
    public Person5(){};
    //构造方法重载
    public Person5(String name, int age){
        this.name = name;
        this.age = age;
    }

    //写一个方法：睡觉
    public void sleep(){
        System.out.println("人在睡觉！");
    }

    //set和get方法
    public void setName(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 15:59:05
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Student extends Person5{
    //学生有学号
    private int sno;
    //子类也有个属性叫age，直接初始化为25
    int age = 25;

    //构造方法
    //缺省构造方法
    public Student(){};
    //一个参数构造防范
    public Student(int sno) {
        this.sno = sno;
    }

    //两个参数构造方法
    public Student(int age, int sno){
        //this调用其他构造方法，必须出现在主体的第一句
        this(sno);
        super.setAge(age);
    }

    //三个参数构造方法
    public Student(String name, int age, int sno) {
        //super调用父类的构造方法，必须出现在主体的第一句
        super(name, age);
        this.sno = sno;
    }

    //重写父类的sleep方法
    @Override
    public void sleep() {
        System.out.println("学生在睡觉！");
    }

    //学生自己的方法，父类没有的方法，读书read
    public void read() {
        System.out.println("学生在读书！");
    }

    //输出age
    public void printAge() {
        System.out.println(age);
        System.out.println(super.age);
    }
}

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 16:27:40
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test06 {
    public static void main(String[] args) {
        //创建Student对象
        Student s1 = new Student("sqlboy",20,26);

        //调用方法
        s1.sleep();//学生在睡觉！
        s1.printAge();//25\n20\n
        s1.read();//学生在读书！
    }
}

修饰符	同一个类	同一个包	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

Object类

1. 所有类都直接或间接的继承自Object类，Object类是所有Java类的根基类；
2. 所有的Java对象都拥有Object类的属性和方法；
3. 如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类；
4. to_String() 方法：返回该对象的字符串表示，经常子类进行重写；
5. equals()方法： 比较两个对象的内容是否相同，经常子类进行重写；

package com.yuzhenc.oop;

import java.util.Objects;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 17:01:07
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person6 {
    private String name;
    private int age;

    public Person6(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person6)) return false;
        Person6 person6 = (Person6) o;//向下转型
        return age == person6.age && Objects.equals(name, person6.name);
    }

    //重写to_String方法
    @Override
    public String toString() {
        return "Person6{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Person6 p6 = new Person6("sqlboy",25);
        Person6 ps6 = new Person6("sqlboy",25);
        System.out.println(p6);//Person6{name='sqlboy', age=25}
        System.out.println(ps6);//Person6{name='sqlboy', age=25}
        //== 比的是地址，所以判断的是否是同一对象
        //equals()方法根据业务规则进行比较，一般比较的是对象的内容
        System.out.println(p6 == ps6);//false
        System.out.println(p6.equals(ps6));//true
    }
}

多态

1. 继承是先有父类再有子类，泛化是先有子类再泛化父类；
2. 多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为；
3. 多态可以提高扩展性，但是扩展性没有达到最好，后面还有反射；
4. 多态要素：继承；重写；父类引用指向子类对象；

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 17:18:04
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Animal {
    //喊叫
    public void shout() {
        System.out.println("我是动物，我可以叫...");
    }
}

class Cat extends Animal {
    //小猫这样叫
    @Override
    public void shout() {
        System.out.println("我是小猫，可以喵喵喵地叫...");
    }
    //挠人
    public void scratch() {
        System.out.println("我是小猫，我可以挠人...");
    }
}

class Dog extends Animal {
    //小狗这样叫
    @Override
    public void shout() {
        System.out.println("我是小狗，可以汪汪汪地叫...");
    }
    //小狗看家护院
    public void guard() {
        System.out.println("我是小狗，我可以看家护院...");
    }
}

class Pig extends Animal {
    @Override
    public void shout() {
        System.out.println("我是小猪，我可以嗯嗯嗯地叫...");
    }
    //小猪吃东西
    public void eat() {
        System.out.println("我是小猪，我可以吃东西...");
    }
}

class Girl {
    //跟动物玩耍
    public void play(Animal animal) {
        animal.shout();
    }
}

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 17:39:31
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test07 {
    public static void main(String[] args) {
        Pig pig = new Pig();
        Girl girl = new Girl();
        Dog dog = new Dog();
        Cat cat = new Cat();
        //女孩和猪玩
        girl.play(pig);//我是小猪，我可以嗯嗯嗯地叫...
        //女孩和狗玩
        girl.play(dog);//我是小狗，可以汪汪汪地叫...
        //女孩和猫玩
        girl.play(cat);//我是小猫，可以喵喵喵地叫...
    }
}