Java 面向对象（封装、继承、多态） 笔记

封装

• 定义：

  封装（Encapsulation）指将实现某种功能的代码包装、隐藏起来。例如：将类的属性设置为 private 的，使用 public 的 get/set 方法来设置。

  封装一个类可以防止该类的代码和数据被其他类访问，访问该类的代码和数据，必须通过严格的接口控制。

• 封装的优点：

  良好的封装能够减少耦合。
  类内部的结构可以自由修改。
  可以对成员变量进行更精确的控制。
  隐藏实现细节。

  封装例子：

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/13.
   */
  public class miLu {
          private String name;
          private int age;
  
          public String getName() {
              return name;
          }
  
          public void setName(String name) {
              this.name = name;
          }
  
          public int getAge() {
              return age;
          }
  
          public void setAge(int age) {
              if (age < 100) {
                  this.age = age;
              }else {
                  System.out.println("age不合法");
              }
  
          }
  }
  
  

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/13.
   */
  public class testFengZhuang {
      public static void main(String[] args) {
          miLu ml = new miLu();
          ml.setAge(1000);
          ml.setName("小白");
  
          System.out.println(ml.getAge());
          System.out.println(ml.getName());
      }
  }
  
  

继承

• 定义：

  继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

  继承是类与类的一种关系，另外类和类之间的关系还有依赖、组合、聚合等。

• 语法：
  格式：

  class 父类 {
  }
   
  class 子类 extends 父类 {
  }
  

• 举例：

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/14.
   */
  public class dongWu {
          String name;
          int age;
          private String kind;
  
          public void eat(){
              System.out.println("吃");
          }
  
          public void sleep(){
              System.out.println("睡");
          }
  
          public void run(){
              System.out.println("逛");
          }
  }
  
  

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/14.
   */
  public class muZhuPeiQi extends dongWu{
          String adress;
          int weight;
  
          public void fight(){
              System.out.println("打人");
          }
  }
  
  

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/14.
   */
  public class testJiCheng {
      public static void main(String[] args) {
          muZhuPeiQi mz = new muZhuPeiQi();
          System.out.println(mz.name);
          System.out.println(mz.adress);
          System.out.println(mz.age);
      }
  }
  
  

• 继承的特点：

  1、（优点）子类拥有父类非 private 的属性、方法。
  2、（优点）子类可以拥有自己的属性和方法，所以子类可以对父类进行扩展。
  3、（优点）子类可以重写父类的方法。
  4、 java中只有单继承没有多继承，java有多重继承，也可以多个类继承一个类，但不能一个类继承多个类（区别于C++）。
  5、 子类和父类之间，是“is a”的关系。
  6、（缺点）提高了类之间的耦合性（耦合度高说明代码之间的联系紧密，代码独立性越差）。

• 关于继承的关键字：

  Object：

   Object类是所有类（不论这个类有没有继承其他类）的父类，
  

  extends：

   有继承关系的两个类中，一个为子类一个为父类，子类使用 extends 继承父类。
  

  super：

   通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
  

  super 和 this 举例：

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/14.
   */
  public class dongWu {
          String name = "动物";
  
          public void eat(){
              System.out.println("父类吃");
          }
  
          public void sleep(){
              System.out.println("父类睡");
          }
  
          public void run(){
              System.out.println("父类逛");
          }
  }
  
  

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/14.
   */
  public class muZhuPeiQi extends dongWu{
          String name = "母猪佩奇";
  
          public void scold(String name){
              System.out.println(name);
              System.out.println(this.name);
              System.out.println(super.name);
              this.eat();
              super.eat();
          }
  
          public void eat(){
              System.out.println("本类吃");
          }
  }
  
  

  package com.baidu.www;
  
  /**
   * Created by joker on 2021/12/14.
   */
  public class testJiCheng {
      public static void main(String[] args) {
          muZhuPeiQi mz = new muZhuPeiQi();
          mz.scold("测试类");
      }
  }
  
  

  测试类
  母猪佩奇
  动物
  本类吃
  父类吃
  
  Process finished with exit code 0
  

  super注意：
  1、子类中无法使用super调用父类私有的属性和方法。
  2、super代表父类，super()代表父类的无参构造方法，如果括号中有参数则代表父类的有参构造方法。
  3、子类中的无参构造方法中，在第一行默认执行父类的无参构造方法（使用隐式的super()，super调用父类的构造方法，必须在构造方法的第一行。
  4、如果使用子类的有参构造方法创建子类的实例对象，也会先调用父类的无参构造方法。
  5、子类的构造方法中（包括有参和无参的所有构造），默认在方法中的第一行都有隐式的调用父类的无参构造方法（即super()）。
  6、写一个类，如果需要使用有参构造，那么最好也手写一个无参构造，这样它的子类在不手写super()时，不会报错。如果没有手写的无参构造方法，子类中的有参构造方法中的第一行必须显示的用super(参数)来调用父类的有参构造方法，同时子类中不能存在无参构造方法。
  7、在子类的构造方法中（不论有参还是无参），都默认使用super()调用父类无参构造。子类的构造方法中，无参构造方法可以使用super调用父类的有参和无参构造方法。子类的有参构造方法可以使用super调用父类的有参和无参构造方法。子类的构造方法可以使用this()也可以使用super() ，但是两者不能同时存在与一个构造方法中。
  8、super必须只能出现在子类的方法或者构造方法中。
  9、super和this不能同时调用构造方法。

super与this区别：
1、代表的对象不同

this：本身调用者这个对象
super：代表父类对象的应用

2、前提

this：没有继承关系也能使用
super：只能在有继承关系时使用

3、构造方法

this：本类的构造
super：父类的构造

4、this调用构造方法也必须在构造方法的第一行，这点与super相同，但是this不能与super同时在构造方法中调用构造方法。

this：

	指向自己的引用。this在哪个类中就属于哪个类，调用的就是哪个类的属性和方法。

查看继承关系的快捷键：ctrl+h