一、封装

1、案例1

package com.msp_oop;

public class Girl {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 30){
            this.age=18;
        }
        else{
            this.age = age;
        }
    }
}

package com.msp_oop;

public class Test {
    public static void main(String[] args) {
        Girl g = new Girl();
//        g.age = 18;
//        System.out.println(g.age);
        g.setAge(50);
        System.out.println(g.getAge());
    }
}

对于age属性，加了修饰符private，这样外界对它的访问就受到了限制，现在我还想加上其他的限制条件，但是在属性本身没有办法再加了，通过定义方法进行限制条件的添加。
以属性为案例：
进行封装:
1、将属性私有化，被private修饰——》加入权限修饰符；一旦加入了权限修饰符，其他人就不可以随意的获取这个属性。
2、提供public修饰的方法让别人来访问/使用
3、即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们方法中加了判断逻辑。
4、实际开发中，方法一般写成setter、getter方法

2、案例2

package com.msp_oop;

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        if ("男".equals(sex) || "女".equals(sex)) {
            this.sex = sex;
        }
        this.sex = "男";
    }

    //加入构造器
    public Student() {

    }

    public Student(int age, String name, String sex) {
        this.name = name;
        this.age = age;
//        this.sex=sex;
        this.setSex(sex);

    }
}

package com.msp_oop;

public class Test_Student {
    public static void main(String[] args) {
        Student st = new Student();
        st.setName("kobe");
        st.setAge(20);
        st.setSex("女");
        System.out.println(st.getName()+"---"+st.getAge()+"---"+st.getSex());

        Student st1 = new Student(40,"james","男1");
        System.out.println(st1.getName()+"---"+st1.getAge()+"---"+st1.getSex());
    }
}

二、继承

提高代码的复用性
父类定义的内容，子类可以直接拿过来用就可以了，不用代码上重复定义。

1、案例1

父类

package com.msp_oop1;

public class Person {
    //属性
    private int age;
    private String name;
    private double height;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
    //方法
    public void eat(){
        System.out.println("eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }


}

子类

package com.msp_oop1;

public class Student extends Person{  //todo 子类继承父类
    private int sno;  //学号

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    //方法
    public void study(){
        System.out.println("study");
    }
}

测试

package com.msp_oop1;

public class Test {
    public static void main(String[] args) {
        Student st = new Student();
        st.setSno(1001);
        st.setName("kobe");
        st.setAge(18);
        System.out.println(st.getName());
        System.out.println(st.getAge());
        System.out.println(st.getSno());

        st.sleep();
    }
}

需要注意：
父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方法，可以间接调用。

2、总结

1、继承关系：父类（基类）/子类（extends）
子类继承父类一定在合理的范围继承
2、好处：
a、提高了代码的复用性
b、便于代码的扩展
c、多态的使用
3、父类private修饰的内容，子类也继承过来了。
4、一个父类可以有多个子类
5、一个子类只能有一个直接父类，但是间接的可以继承其他类
6、继承具有传递性
Student——》继承Person——》继承Object

三、多态

1、现有父类，再有子类，叫继承；现有子类，再抽取父类，叫泛化；
2、什么是多态？
多种状态，同一个行为，不同的子类，表现出不同的形态；
多态指的是同一个方法调用，由于对象不同会产生不同的行为。
3、多态的好处：
提高代码的扩展性，符合面向对象的设计原则，开闭原则。
开闭原则：扩展开发，修改关闭。
4、多态的三个要素：
a、继承：Cat——》Animal；Dog——》Animal
b、重写：play()方法
c、父类引用指向子类对象

Dog dog = new Dog();
Animal animal = dog; 
==转化为
Animal animal = new Dog(); 
girl.play(animal )

public void play(Animal an) {
        an.play();
    }

上面的代码，也是多态的一种非常常见的应用场合：父类当方法的形参，然后传入的是具体的子类的对象，然后调用同一个方法，根据传入的子类的不同展现的效果也不同，构成了多态。

1、案例

父类

package com.msb_duotai;

public class Animal {
    public void play() {
        System.out.println("我是小动物，");
    }
}

子类

package com.msb_duotai;

public class Cat extends Animal {
    public void play() {
        System.out.println("和猫玩");
    }
}

package com.msb_duotai;

public class Dog extends Animal {
    public void play(){
        System.out.println("和狗玩");
    }
}

儿童类

package com.msb_duotai;

public class Girl {
    //    public void play(Cat cat){
//        cat.play();
//    }
//
//    public void play(Dog dog){
//        dog.play();
//    }
    //和小动物玩
    public void play(Animal an) {
        an.play();
    }
}

测试类

package com.msb_duotai;

public class Test {
    public static void main(String[] args) {
        Girl girl = new Girl();
//        Cat cat = new Cat();
//        girl.play(cat);
//
//        Dog dog = new Dog();
//        girl.play(dog);

        //动物
        Cat cat = new Cat();
        Dog dog = new Dog();
        Animal animal = dog; // TODO: 2024/6/9
        girl.play(animal);

    }
}

四、权限修饰符

1、private

在当前类中可以访问

2、default

同一个包下的其他类都可以访问

3、protected

权限到不同包下的子类

4、public

在整个项目中都可以访问

总结：
属性、方法，修饰符有四种
private、缺省、protected、public
类修饰符两种：缺省、public
一般属性：用private修饰
一般方法：用public修饰

五、工厂设计模式

定义一个static方法，通过类名直接调用
返回值类型是父类类型，返回的可以是其任意子类类型
传入一个字符串类型的参数，工厂根据参数创建对应的子类产品

package com.msb_duotai;

public class PetStore {   //工厂类

    public static Animal getAnimal(String petName) {  //todo 加上static可以通过类名.方法名去调用
        Animal an = null;
        if ("猫".equals(petName)) {
            an = new Cat();
        }
        if ("狗".equals(petName)) {
            an = new Dog();
        }
        return an;
    }
}

package com.msb_duotai;

public class Dog extends Animal {
    public void play() {
        System.out.println("和狗玩");
    }
}

package com.msb_duotai;

public class Cat extends Animal {
    public void play() {
        System.out.println("和猫玩");
    }
}

package com.msb_duotai;

public class Girl {
    //和小动物玩
    public void play(Animal an) {
        an.play();
    }
}

package com.msb_duotai;

public class Test {
    public static void main(String[] args) {
        Girl girl = new Girl();

        Animal an=PetStore.getAnimal("狗");
        girl.play(an);

    }
}