Java的三大特性，封装，继承，多态

一，特性

Java的三大特性，封装，继承，多态。

1、面向对象与面向过程

1.1、什么是面向过程？

面向过程：
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

举例来说，大象装进冰箱需要几步？

按照面向过程思想：
第一步：工作人员去打开冰箱门
第二步：把大象塞进冰箱
第三步：工作人员把冰箱门关上
诶，这里我们就看出来了，面向过程就是把一件事按步骤一步一步来实现
用代码表示

    public void openDoor(){}  //开门
    public void putIn(){}       //装冰箱
    public void closeDoor(){}   //关门

依次调用这些方法就完成了

1.2、什么是面向对象？

对象，就是对问题中的事物的抽象
面向对象：
就是把现实中的事物都抽象为“对象”。每个对象是唯一的，且都可以拥有它的属性与行为。我们就可以通过调用这些对象的方法、属性去解决问题。

用面向对象思想解决大象装进冰箱

大致的了解到了对象这个概念，可以说是对现实事物的一种抽象映射。

例如在这个事件中：
冰箱作为一个对象；
大象作为一个对象。
冰箱有这些功能：开门、装物体、关门

class fridge{
    public void open(大象){}   //开门
    public void putIn(大象){}  //放进冰箱
    public void close(大象){}  //关门
}
class elephant{
	public void eat(){}   //吃
}

看出来了什么？每个对象是独立的，有属于它自己的功能，只需要专心实现自己的功能就好。所以在建立对象模型阶段，仅仅关注对象有什么的功能，但不考虑如何实现这些功能。

面向对象的好处，就包括有很好的延展性，比如我给大象赋予了一个吃的功能，它通过调用就可以在冰箱里去吃东西。面向对象就是把现实问题抽象为对象，通过调用每个对象的属性或功能去解决问题。

如果我要修改我的需求，把大象换成兔子，我用面向过程是不是得把每个步骤中的大象改为兔子。而用面向对象解决，我甚至可以重新创一个兔子对象，仅仅在调用的时候选择兔子就行了。

2、类与对象的关系

很多人都会创建对象，不就是new嘛，调用对象方法不就是new.方法嘛。结果，有部分人在new类的时候，就下意识的把类当成了对象，那么类到底是不是对象呢？

肯定不是，先给出他们的基本概念

2.1、基本概念

对象
对象是由数据（描述事物的属性）和作用于数据的操作（体现事物的行为）组成的封装体，描述客观事物的一个实体，是构成系统的基本单元。

类
类是对一组有相同数据和相同操作的对象的定义，是对象的模板，其包含的方法和数据描述一组对象的共同行为和属性。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类可有其子类，也可有其他类，形成类层次结构。

2.2、类与对象的区别

1）类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。

2）类是一组具有相同属性和行为的对象的抽象。我们可以将类看做是创建对象蓝图，对象根据这个蓝图去具体实现某个东西。

比如来说，给一张“伞”的蓝图，我们设计出了晴雨伞，剑伞等等，你会发现，这些伞都有相同的行为呀----遮雨。

所以，类的实例化结果就是对象，而对一类对象的抽象就是类，类描述了一组有相同属性和相同方法的对象。

3、基本特征：封装、继承、多态

3.1、封装

（一）基本概念
封装(encapsulation)即信息隐蔽。它是指在确定系统的某一部分内容时，应考虑到其它部分的信息及联系都在这一部分的内部进行，外部各部分之间的信息联系应尽可能的少。

（二）四种访问控制级别

• public：对外公开，访问级别最高
• protected：只对同一个包中的类或者子类公开
• 默认：只对同一个包中的类公开
• private：不对外公开，只能在对象内部访问，访问级别最低
  

二，封装

2.1，封装是什么

封装的概述：
有的类更多的定义属性和get及set方法，一般用来存储数据和操作数据
标准的类：属性（变量）、无参构造方法、有参构造方法、针对属性get和set方法，成员方法（功能）,toString（方便打印类）
有的类更多定义的是方法， 是用来提供功能的
 

• 将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。
• 通过该类提供的方法来实现对隐藏信息的操作和访问。
• 隐藏对象的信息。
• 留出访问的对外接口。

 

2.2，封装的特点

• 对成员变量实行更准确的控制。
• 封装可以隐藏内部程序实现的细节。
• 良好的封装能够减少代码之间的耦合度。
• 外部成员无法修改已封装好的程序代码。
• 方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
• 便于修改，体高代码的可维护性。

2.3，封装的使用

• 使用private修饰符，表示最小的访问权限。

• 对成员变量的访问，统一提供setter，getter方法。

  一个Student实体对象类：

  package Fuxi;
  
  public class Student {
  
      // 属性
      private String name;
      private String sex;
      private int age;
      private double height;
  
      // 无参构造函数
      public Student() {
      }
  
      // 有参构造函数
      public Student(String name, String sex, int age, double height) {
          this.name = name;
          this.sex = sex;
          if (age>0 && age<=200){
              this.age = age;
          }
          if (height>0){
              this.height = height;
          }
      }
  
      // getter setter 方法
      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;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          if (age>0 && age<=200){
              this.age = age;
          }
      }
  
      public double getHeight() {
          return height;
      }
  
      public void setHeight(double height) {
          if (height>0){
              this.height = height;
          }
      }
  
      // toString 方法
      @Override
      public String toString() {
          return "TestStudent{" +
                  "name='" + name + '\'' +
                  ", sex='" + sex + '\'' +
                  ", age=" + age +
                  ", height=" + height +
                  '}';
      }
  }
  

  三，继承

  3.1，什么是继承

  ​ 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

  3.2，继承的特点

  1，关于继承的注意事项：

  ​ 只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。

  ​ 子类可以拥有父类的属性和方法。

  ​ 子类可以拥有自己的属性和方法。

  ​ 子类可以重写覆盖父类的方法。

  2，继承的特点：

     提高代码复用性。
  
     父类的属性方法可以用于子类。
  
     可以轻松的定义子类。
  
     使设计应用程序变得简单。
  

  3.3，继承的使用

  ​ 1，在父子类关系继承中，如果成员变量重名，则创建子类对象时，访问有两种方式。

  a，直接通过子类对象访问成员变量

  ​ 等号左边是谁，就优先使用谁，如果没有就向上找。

  b，间接通过成员方法访问成员变量

  该方法属于谁，谁就优先使用，如果没有就向上找。

  public class FU {
      int numFU = 10;
      int num = 100;
      public void method(){
          System.out.println("父类成员变量："+numFU);
      }
      public void methodFU(){
          System.out.println("父类成员方法!");
      }
  }
  

  public class Zi extends FU{
      int numZi = 20;
      int num = 200;
      public void method(){
          System.out.println("子类成员变量："+numFU);
      }
      public void methodZi(){
          System.out.println("子类方法！");
      }
  }
  

  public class ExtendDemo {
      public static void main(String[] args) {
          FU fu = new FU();
          // 父类的实体对象只能调用父类的成员变量
          System.out.println("父类：" + fu.numFU);   // 结果：10
          
          Zi zi = new Zi();
          System.out.println("调用父类：" + zi.numFU); // 结果：10
          System.out.println("子类：" + zi.numZi);   // 结果：20
  
          /** 输出结果为200，证明在重名情况下，如果子类中存在则优先使用，
           *  如果不存在则去父类查找，但如果父类也没有那么编译期就会报错。
           */
          System.out.println(zi.num); // 结果：200
          /**
           * 通过成员方法调用成员变量
           */
          zi.method();    // 结果：10
      }
  }
  

  2，同理：

  ​ 成员方法也是一样的，创建的对象是谁，就优先使用谁，如果没有则直接向上找。
  ​ 注意事项：

  ​ 无论是成员变量还是成员方法，如果没有都是向上父类中查找，绝对不会向下查找子类的。

  3，在继承关系中，关于成员变量的使用：

  ​ 局部成员变量：直接使用
  ​ 本类成员变量：this.成员变量
  ​ 父类成员变量：super.父类成员变量

  int numZi = 10;
   public void method() {
     int numMethod = 20;
     System.out.println(numMethod);  // 访问局部变量
     System.out.println(this.numZi); // 访问本类成员变量
     System.out.println(super.numFu); // 访问本类成员变量
  }
  

  3.4，重写，重载

  ​ 重写

  ​ 是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

  package animal;
  /**
   * 哺乳动物的接口
   * @author Admin
   *
   */
  public interface Mammal {
  	//捕食
  	void bushi();
  	//生活方式
  	void shenghuo();
  }
  
  package animal;
  /**
   * 陆生生物，实现Mammal接口
   * @author 小m
   *
   */
  public abstract class Terrestrial implements Mammal{
  	//创建属性
  	//体重
  	public int weight;
  	//年龄
  	public int age;
  	//实现生活方式
  	public void shenghuo() {
  		System.out.println("陆地生活动物");
  	}
  	//保留捕食抽象方法，交给具体子类实现
  	public abstract void bushi();
  }
  
  
  package animal;
  
  /**
   * 海洋动物，实现哺乳动物接口
   * 
   * @author 小m
   *
   */
  public abstract class Halobios implements Mammal {
  	// 创建属性
  	// 体重
  	public int weight;
  	// 年龄
  	public int age;
  
  	// 实现生活方式
  	public void shenghuo() {
  		System.out.println("海洋生活动物");
  	}
  
  	// 保留捕食抽象方法，交给具体子类实现
  	public abstract void bushi();
  
  }
  

  ​ 重写的规则：

     1 .在继承中 方法名称一样,参数类型一样,返回值一样(三同原则)

  重载(overload)

  ​ 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

  ​ 最常用的地方就是构造器的重载。

   public class TextCs {
       public int test(){
           System.out.println("test1");
           return 1;
       }
       public void test(int a){
           System.out.println("test2");
       }   
       //以下两个参数类型顺序不同
       public String test(int a,String s){
           System.out.println("test3");
           return "returntest3";
       }   
       public String test(String s,int a){
           System.out.println("test4");
           return "returntest4";
       }    
       public static void main(String[] args){
           Overloading o = new Overloading();
           System.out.println(o.test());
           o.test(1);
           System.out.println(o.test(1,"test3"));
           System.out.println(o.test("test4",1));
       }
   }

​ 重载规则：

​ 1，被重载的方法必须改变参数列表（参数个数或者类型不一样）。

​ 2，被重载的方法可以改变返回类型。

​ 3，被重载的方法可以改变访问修饰符。

3.5，this，super关键字

super()关键字的用法
​ 1，子类的成员方法中，访问父类的成员变量。

​ 2，子类的成员方法中，访问父类的成员方法。
3，子类的构造方法中，访问父类的构造方法。

this关键字用法：
​ 1，本类成员方法中，访问本类的成员变量。
​ 2，本类成员方法中，访问本类的另一个成员方法。
3，本类的构造方法中，访问本类的另一个构造方法。

• this关键字同super一样，必须在构造方法的第一个语句，且是唯一的。
• this与super不能同时存在。

3.6，构造方法

​ 继承关系中，父子类构造方法的访问特点：
​ 1，在子类构造方法中有一个默认隐含的super();调用，因此一定是先调用父类构造方法，再调用子类构造方法。
​ 2，子类构造可以通过super();调用父类的重载构造。(重载)
​ 3，super();的父类调用构造方法，必须在子类构造中的第一行，就是第一个;号结束的元素，并且只能调用一次。

3.7，关于继承的注意事项：

​ 1，Java语言是单继承的，一个子类只能有唯一一个父类
​ 2，Java语言可以是多级继承，一个子类有一个父类，一个父类还可以有一个父类。
​ 3，一个子类只有一个父类，但是一个父类可以有多个子类。

四，多态

4.1，什么是多态

​ 多态是同一个行为具有多个不同表现形式或形态的能力。

4.2，多态的特点

​ 1，消除类型之间的耦合关系，实现低耦合。

​ 2，灵活性。

​ 3，可扩充性。

​ 4，可替换性。

4.3，多态的体现形式

• 继承

• 父类引用指向子类

• 重写

  ​ 注意：在多态中，编译看左边，运行看右边

4.4，向上转型

1，格式：父类名称 对象名 = new 子类名称(); 
      含义：右侧创建一个子类对象，把它当作父类来使用。
      注意：向上转型一定是安全的。
      缺点：一旦向上转型，子类中原本特有的方法就不能再被调用了。	

五，接口

接口类

      所有的方法都是抽象的

      格式: 

           public interface A(){}

           子类实现A  A:父类(超类或基类) B:子类(派生类)

           public class B implements A (){}

       属性 

           用 public final static三个修饰符 ，等同于常量

           格式：public final static 数据类型  自定义名称 =XXXX;

       行为

           public abstract 返回值类型 自定义的方法名();    

       接口的特点

        （1）不可以创建对象（因为是特殊的抽象类,因为抽象的方法没有任何的意义)。

        （2）子类需要重写接口中所有的抽象方法。子类就可以实例化（可以new 对象）

        （3）类可以实现多个接口（解决了继承的弊端）implements实现父类接口

      

     接口和抽象类的区别

        1. 类只能继承一个类

          类可以实现多个接口

        2. 接口中定义的变量是一个常量，抽象类中定义的是字段属性

        3. 抽象类中可以有具体的方法，也可以有抽象方法

           接口中所有的方法都是抽象的