封装(Encapsulation)

生活案例

ATM、电线

Java中封装的理解

将某些东西进行隐藏，然后提供相应的方式进行获取。
我们程序设计追求“高内聚，低耦合”。
➢高内聚:类的内部数据操作细节自己完成，不允许外部干涉;
➢低耦合:仅对外暴露少量的方法用于使用。 
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提
高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露
的暴露出来。这就是封装性的设计思想。

封装的好处

提高代码的安全性

代码：通过一个属性感受封装：

public class Girl {
    
    //女孩
    //属性：
    private int age;
    //读取年龄：
    public int duquAge(){
    
    
        return age;
    }
    //设置年龄：
    public void shezhiAge(int age){
    
    
        if(age >= 30 ){
    
    
            this.age = 18;
        }else{
    
    
            this.age = age;
        }
    }
}

public class Test {
    
    
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
    
    
        //创建一个Girl类的对象：
        Girl g = new Girl();
        /*g.age = 33;
        System.out.println(g.age);*/
        //设置年龄：
        g.shezhiAge(31);
        //读取年龄：
        System.out.println(g.duquAge());
    }
}
测试结果：
18

上面的代码，对于属性age来说，我加了修饰符private，这样外界对它的访问就受到了限制，现在我还想加上其他的限制条件，但是在属性本身上没有办法再加了，所以我们通过定义方法来进行限制条件的添加

以属性为案例：
进行封装：
（1）将属性私有化，被private修饰--》加入权限修饰符
一旦加入了权限修饰符，其他人就不可以随意的获取这个属性
（2）提供public修饰的方法让别人来访问/使用
（3）即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们在方法中可以加入 限制条件。

实际开发中，方法一般会写成 setter，getter方法：
可以利用IDEA快捷键生成：alt+insert -->getter and setter:

加深练习

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) {
    
    
//        this.sex = sex;
        if("男".equals(sex) || "女".equals(sex)){
    
    
            this.sex = sex;
        }else{
    
    
            this.sex="男";
        }
    }

    public Student() {
    
    //定义其他带参构造器就必须把空参构造器写上，不然系统不会默认产生空参而报错
    }

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


    public static void main(String[] args) {
    
    
        Student s1 = new Student();
        s1.setAge(11);
        s1.setName("张三");
        s1.setSex("女");
        System.out.println(s1.getName()+s1.getAge()+"岁是"+s1.getSex()+"的");

        Student s2 = new Student(22,"李四","shhfbben55444");
        System.out.println(s2.getName()+s2.getAge()+"岁是"+s2.getSex()+"的");
    }
}
运行结果：
张三11岁是女的
李四22岁是男的

继承(Inheritance)

类是对对象的抽象

举例：
荣耀20 ，小米 红米3，华为 p40 pro   ---> 类：手机类

继承是对类的抽象

举例：
学生类：Student：
属性：姓名，年龄，身高，学生编号
方法：吃饭，睡觉，喊叫，学习

教师类：Teacher:
属性：姓名，年龄，身高，教师编号
方法：吃饭，睡觉，喊叫，教学

员工类：Emploee:
属性：姓名，年龄，身高，员工编号
方法：吃饭，睡觉，喊叫，工作

共同的东西：
人类：
属性：姓名，年龄，身高
方法：吃饭，睡觉，喊叫

学生类/教师类/员工类  继承 自   人类  

以后定义代码：
先定义人类：
人类： ---》父类，基类，超类
属性：姓名，年龄，身高
方法：吃饭，睡觉，喊叫

再定义 ： ---》子类，派生类

学生类：Student：
属性：学生编号
方法：学习

教师类：Teacher:
属性：教师编号
方法：教学

员工类：Emploee:
属性：员工编号
方法：工作 

狗类：
属性：姓名，年龄，身高
方法：吃饭，睡觉，喊叫


我们的继承关系，是在合理的范围中进行的抽取 ，抽取出子类父类的关系：
上面的案例中：
学生类/教师类/员工类  继承 自   人类   ---》合理
学生类/教师类/员工类  继承 自   狗类   ---》不合理

区分：
学生是一个人
教师是一个人
员工是一个人   ---》合理

学生是一个狗    ---》不合理

总结：继承 就是  is - a 的关系 

代码层面解释

先写父类，再写子类：

父类：人类 Person
子类：学生类 Student

public class Person {
    
    
    //属性：
    private int age;
    private String name;
    private double height;
    //提供setter getter方法：
    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("可以吃饭。。。");
    }
    public void sleep(){
    
    
        System.out.println("可以睡觉。。。");
    }
}

public class Student extends Person {
    
    //子类Student 继承  父类Person
    //属性：
    private int sno;//学号
    public int getSno() {
    
    
        return sno;
    }
    public void setSno(int sno) {
    
    
        this.sno = sno;
    }
    //方法：
    public void study(){
    
    
        System.out.println("学生可以学习");
    }
 //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
    
    
        //创建子类Student的对象
        Student s = new Student();
        s.setSno(1001);
        s.setAge(18);
        s.setName("菲菲");
        s.setHeight(180.4);
        System.out.println("学生名字为："+s.getName()+",学生的年纪："+s.getAge());
        //访问方法：
        s.study();
        s.eat();
        s.sleep();
    }
}

运行结果：
学生名字为：菲菲,学生的年纪：18
学生可以学习
可以吃饭。。。
可以睡觉。。。

继承的好处

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

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

内存分析

权限修饰符

【1】private：权限：在当前类中可以访问

【2】default:缺省修饰符：权限：到同一个包下的其他类都可以访问

【3】protected：权限：最大到不同包下的子类

【4】public：在整个项目中都可以访问

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

以后写代码
一般属性：用private修饰 ，方法：用public修饰

继承条件下构造方法的执行过程

总结

（1）继承关系 ：
	父类/基类/超类
	子类/派生类
	子类继承父类一定在合理的范围进行继承的    子类 extends  父类
（2）继承的好处：
	1.提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代		码上反复重复定义了
	2.便于代码的扩展
	3.为了以后多态的使用。是多态的前提。
（3）父类private修饰的内容，子类也继承过来了。
（4）一个父类可以有多个子类。
（5）一个子类只能有一个直接父类

	但是可以间接的继承自其它类。
（6）继承具有传递性：
	Student --》继承自  Person  ---》继承自Object
	Object类是所有类的根基父类。
	所有的类都直接或者间接的继承自Object。

多态(Polymorphism)

多态跟属性无关，多态指的是方法的多态，而不是属性的多态。

案例代入

public class Animal {
    
    //父类：动物：
    public void shout(){
    
    
        System.out.println("我是小动物，我可以叫。。。");
    }
}

public class Cat extends Animal{
    
    
    //喊叫方法：
    public void shout(){
    
    
        System.out.println("我是小猫，可以喵喵叫");
    }
    public void scratch(){
    
    
        System.out.println("我是小猫，我可以挠人");
    }
}

public class Dog extends Animal{
    
    
    //喊叫：
    public void shout(){
    
    
        System.out.println("我是小狗，我可以汪汪叫");
    }
    public void guard(){
    
    
        System.out.println("我是小狗，我可以看家护院，保护我的小主人。。。");
    }
}

public class Pig extends Animal{
    
    
    public void shout(){
    
    
        System.out.println("我是小猪，我嗯嗯嗯的叫");
    }
    public void eat(){
    
    
        System.out.println("我是小猪，我爱吃东西。。");
    }
}

public class Girl {
    
    
    //跟猫玩耍：
    /*public void play(Cat cat){
        cat.shout();
    }*/
    //跟狗玩耍：
    /*public void play(Dog dog){
        dog.shout();
    }*/
    //跟小动物玩耍：
    public void play(Animal an){
    
    
        an.shout();
    }
}

public class Test {
    
    
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
    
    
        //具体的猫：--》猫的对象
        //Cat c = new Cat();
        //具体的小女孩：--》女孩的对象
        Girl g = new Girl();
        //小女孩跟猫玩：
        //g.play(c);
        //具体的狗---》狗的对象：
        //Dog d = new Dog();
        //小女孩跟狗玩：
        //g.play(d);
        //具体的动物：--》动物的对象：
        //Cat c = new Cat();
        //Dog d = new Dog();
        Pig p = new Pig();
        Animal an = p;
        g.play(an);
    }
}

多态的好处

为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。
开闭原则：指的就是扩展是 开放的，修改是关闭的。
注意：多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习 反射

多态的要素

一，继承： Cat extends Animal ,Pig extends Animal, Dog extends Animal
二，重写：子类对父类的方法shout()重写
三， 父类引用指向子类对象：

Pig p = new Pig();
Animal an = p;

将上面的代码合为一句话：
Animal an = new Pig();
=左侧：编译期的类型
=右侧：运行期的类型

public void play(Animal an){//Animal an = an = new Pig();
        an.shout();
    }

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

内存分析

总结

（1）先有父类，再有子类：--》继承   先有子类，再抽取父类 ----》泛化 
（2）什么是多态：
多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。
多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。