面向对象三大特性 继承 封装 多态

封装（面向对象的三大特性：继承、封装、多态）

1. 该露的露，该藏的藏

   • 程序设计追求高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

2. 封装（数据的隐藏）

   • 通常，应禁止访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
   • 属性私有，get/set
   • 封装大多数是对于属性来的，对于方法的很少
   • 提高程序的安全性，保护数据
   • 隐藏代码的实现细节
   • 统一接口
   • 提高了系统的可维护性

3. //类  private：私有
   public class Student {
       //属性私有
       private String name;//名字
       private int id;//学号
       private char sex; //性别
       private int age;//年龄
   
       //提供一些可以操作这个属性的方法
       //提供一些public的get、set方法
   
       //get获得这个数据
       public String getName(){
           return this.name;
       }
       //set给这个数据设置值
       public void setName(String name){
           this.name = name;
       }
   
       //alt+insert
   
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           this.id = id;
       }
   
       public char getSex() {
           return sex;
       }
   
       public void setSex(char sex) {
           this.sex = sex;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           if(age<120&&age>0){
               this.age = age;
           }else{
               this.age = 3;
           }
       }
   }
   
   /*
   //    import com.qieyun.oop.demo04.Student;
   //    封装的意义：1.提高程序的安全性，保护数据
   //               2.隐藏代码的实现细节
   //               3.同意接口
   public class Application {
       public static void main(String[] args) {
           Student s1 = new Student();
           s1.setName("惬允");
           System.out.println(s1.getName());
           s1.setAge(999);//不合法
           System.out.println(s1.getAge());
       }
   }
   */
   

继承

1. 继承的本质是对某一批类的抽象，从而实现对象对现实世界更好地建模

2. extends的意思是“扩展”。子类是父类的扩展。

3. JAVA中类只有单继承，没有多继承！一个儿子有一个爸爸，一个爸爸能有多个儿子

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

5. 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

6. 子类和父类之间，从意义上来讲应该是具有“is a”的关系

7. //学生 is 人：派生类，子类
   //子类继承了父类，就会拥有父类的全部方法
   public class Student extends Person{
   
       //ctrl + H   继承树
   }
   
   /*
   import com.qieyun.oop.Demo05.Student;
   
   public class Application{
       public static void main(String[] args) {
           Student student = new Student();
           student.say();
           System.out.println(student.getMoney());
       }
   }
   */
   /*
   //person 人：父类
   public class Person {
       //public
       //protected
       //default
       //private
       private int money = 10_0000_0000;
   
       public void say(){
           System.out.println("说了一句话");
       }
   
       public int getMoney() {
           return money;
       }
   
       public void setMoney(int money) {
           this.money = money;
       }
   }
   */
   

8. object类 所有类都直接或者间接继承object类

9. super 这个关键字可以用来子类访问父类

10. 方法重写

11. 私有的东西无法被继承

重写

1. 只有非静态方法能重写
2. 重写中关键字只能是public，不能是私有的

多态

1. 动态编译：类型：可扩展性
2. 同一种方法可以根据发送对象的不同而采用多种不同的行为方式
3. 一个对象的实际类型是确定的，但可以指向的对象的引用类型很多（父类，或者有关系的类）
4. 多态存在的条件
   • 有继承关系
   • 子类重写父类方法
   • 父类引用指向子类对象
5. 注意：多态是方法的多态，属性没有多态性
6. instanceof 类型转换~引用类型，判断一个对象是什么类型
7. instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例