面向对象二

封装

该露的露，该藏的藏
- 我们设计程序要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴漏少量的方法给外部使用。
封装(数据的隐藏)
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句就够了：私有属性，get/set

里面的属性是私有的所有要用get/set方法来获取，和设置

//类    private:私有
public class Student {
   private String name; //名字
   private int id; //学号
   private char sex;//性别

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

   //get 获得这个数据
   public String getName(){

       return this.name;
   }

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

public static void main(String[] args) {
       Student s1 = new Student();
       s1.setName("qingjiang");

       System.out.println(s1.getName());
   }

继承

继承的本质是对某一批类的对象，从而实现对现实世界更好的建模
extands的意识是"扩展"。子类是父类的扩展。
java类中只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类用关键词extends来表示
子类和父类之间从某种意义上有"is a"的关系
Object类
super -- this
方法重写：重点 ---> 多态

案例:(继承)

//Person 人:  父类
public class Person { 
  //public protected default private

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

Person(){
   System.out.println("Person被执行了");
}}

//学生 is 人 : 派生类,子类
//子类继承了父类，就会拥有父类的全部方法！
//在java中，所有的类，都默认直接或间接继承Object
public class Student1 extends Person{
  public Student1(){
      //隐藏代码；调用了父类的无参构造
      super();
      System.out.println("Student被执行了");
  }

  public void print(){

      System.out.println("Student");
  }

  public void test1(){
      say();
      print();
      this.print();

  }

}

public static void main(String[] args) {
      Student1 student = new Student1();
      student.test1();
  }

案例:(重写)

public class B {
  public static void test(){
      System.out.println("B=>text()");
  }
}

public class A extends B{
  public static void test(){
      System.out.println("A=>text()");
  }
}

public static void main(String[] args){
      A a = new A();
      a.test();      //A

      //父类的引用指向了子类
      B b = new A();
      b.test();      //B
  }

方法调用只和左边，定义的数据类型有关系
重写是方法的重写和属性无关

小结:
- super注意点：
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的构造方法之中
- super 和 this 不能同时调用构造方法
- Vs this
- 代表对象不同:this : 本身调用这个对象 | super：只用在继承条件才可以使用构造方法
- this 本类的构造
- super 父类的构造
- 重写: 需要有继承关系，子类重写父类的方法
- 方法名必须相同
- 参数列表列表必须相同
- 修饰符：范围可以扩大但是不能缩小 -->public-->protected-->default-->private
- 抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
- 重写，子类的方法和父类必须一致；方法体不同！
- 为什么要重写：
- 父类的功能，子类不一定需要，或者不一定满足！
- Alt + Insert; override;

多态

即同一种方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态。
instanceof

案例:

public class Person1 {

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

public class Student extends Person1{

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

public static void main(String[] args) {

       //一个对象的实际类型是确定的，new Student(); new Person();
       //可以指向的引用类型就不确定了：父类的引用指向子类

      //Student 能调用的方法都是自己或继承父类的
      Student s1 = new Student();

      //Person 父类型，可以指向子类，但是不能调用子类独有的方法
      Person1 s2 = new Student();
      Object s3 = new Student();

      //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
      ((Student) s2).eat(); //子类重写了父类的方法，执行了子类的方法。
      s1.eat();
  }

多态注意事项：
- 多态是方法的多态，属性没有多态
- 父类和子类有连系才能将父类引用类型指向子类的实际类型！否则就报类型转换异常 ClassCastException!
- 多态存在的必要条件：
  - 继承关系
  - 方法需要重写
  - 父类引用指向子类对象! Father f1 = new Son();
- 一些不能重写的方法
  - static 方法，属于类，它不属于实例
  - final 常量；是在常量池里面的
  - private 方法

扩展:关键字 instanceof (判断一个对象是什么类型) 和引用类型转换

案例:

public class Person2 {
}

public class Student extends Person2 {
}

public class Teacher extends Person2{
}

public static void main(String[] args) {
       //Object > String
       //Object > Person > Teacher
       //Object > Person > Student
       Object object = new Student();
       System.out.println(object instanceof Student);//true
       System.out.println(object instanceof Person2);//true
       System.out.println(object instanceof Object);//true
       System.out.println(object instanceof Teacher);//false 另外一条线了，跟student无关了
       System.out.println(object instanceof String);//false
       System.out.println("======================================");
       Person2 person = new Student();
       System.out.println(person instanceof Student);//true
       System.out.println(person instanceof Person2);//true
       System.out.println(person instanceof Object);//true
       System.out.println(person instanceof Teacher);//false
       //System.out.println(person instanceof String);//编译报错
       System.out.println("======================================");
       Student student = new Student();
       System.out.println(student instanceof Student);//true
       System.out.println(student instanceof Person2);//true
       System.out.println(student instanceof Object);//true
       //System.out.println(student instanceof Teacher);//编译报错
       //System.out.println(student instanceof String);//编译报错
   }