java的封装，继承，多态

封装

• 该露的露，该藏的藏
  • 我们涉及要追求“高内聚，低耦合”。高内聚就是类的内部数据结构操作细节自己完成，不允许外部干涉；低耦合:仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 属性私有 get/set
• 提高程序的安全性，保护数据
• 隐藏代码的实现细节
• 统一接口
• 系统可维护增加
  
• alt+insert（fn+insert键）可以自动生成get/set方法

package oop.Demo01;
//封装类
public class Student {
    //名字
    public String name;
    //性别
    private char sex;
    //学号
    private  int id;
    //学习（）
    //睡觉（）

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

    //get获得这个数据
    public String getName(){
        return this.name;
    }

    //set设置这个数据
    public void setName(String name){
        this.name=name;
    }   
}

package oop;
//调用类
import oop.Demo01.Student;

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

        //调用Student中的公共方法setName,设置值
        // 在Student中传参给name
        s1.setName("张麦麦");
        System.out.println(s1.getName());
        System.out.println("---------------------");
        System.out.println(s1.name);
    }
}

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界建模
• extands的意思是“扩展”，子类是父类的扩展

//person人，父类
public class person {

}

//学生是人，继承了人的特点，子类
public class student extends person{
}

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

• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，聚合，组合等。

• 选中子类任一码语句，CTRL+h即可打开继承树
  

• super
  

• super注意点：

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

• Vs this:

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

• 方法重写

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件
• 有继承关系
• 子类重写父类方法父类引用指向子类对象
• 注意:多态是方法的多态，属性没有多态性。
• Father s1 = new Son();
• alt+insert，选择Override可以在子类中重写父类方法
  

package oop.Demo03;
//父类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

package oop.Demo03;
//子类
public class Student extends Person{
    //子类重写父类方法
    @Override
    public void run() {
        System.out.println("son");
    }

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

package oop.Demo03;

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

        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Person();

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

        //此处s2的eat会报错， 对象能执行哪些方法，
        // 主要看对象左边的类型，和右边关系不大
        //s2.eat();
        //类型转换，高转低，父类转子类
        ((Student)s2).eat();
        s1.eat();
    }
}

• 哪些方法不能被重写：static，静态方法属于类，不属于实例
• final常量池里的，不能改的
• private私有，不能被调用，不能重写，没有多态