搞不清楚 封装、继承、多态？一篇文章解决

我们已经基本了解了面向对象的一些概念 java基础—面向对象

敲黑板！！现在我们来看看面向对象的 三大特征 封装 ，继承 ，多态

封装

分装应该很好理解，字面上来看，把一个东西装起来，密封好（用胶布，还是用老坛酸菜的罐子也好），就是把一个东西装起来

在java中，封装，封装什么？不用想，肯定是封装代码了，官方是这么定义的：

封装是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

看不懂？没关系，又到了说人话的环节

封装就是把数据（代码）给藏起来

并且！！给这个数据给以调用的权限范围，对信息进行隐藏，提供对外可访问的方法

这么做肯定是有好处的：

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

来个例子：

比如说 人 ，我们都知道人 都有姓名，年龄 ，所以我们把这个共性提取出来

就生成了一个 person 类 ，并且设置 这些属性为私有的

public class Person {
    private String name;
    private int age;
}

private 修饰的变量，我们都知道是私有的，只有在本类中才能访问，所以这里对信息进行了隐藏

外部想要访问我们怎么办？ 提供给他访问的公共方法就好了

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

    public void setName(String name){
      this.name = name;
    }
}

这里的getter和setter方法就是

那么访问就可以通过提供的方法来访问，给人这个对象设置名字，年龄，一个公共的类 可以创建多个不同的 对象

public static void main(String args[]){
   Person person1 = new Person();
        person1.setName("张三");
        person1.setAge(18);
   Person person2 = new Person();
        person2.setName("李四");
        person2.setAge(20);
   System.out.println("我造的第一个人, 名字:"+person1.getName()+"年龄"+person1.getAge());
   System.out.println("我造的第二个人, 名字:"+person2.getName()+"年龄"+person2.getAge());
    }

输出结果：

继承

继承也很好理解，子类继承父类的特征和行为，就是儿子继承父亲

在java里面继承 用 extends 关键字来说明

语法格式：

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

为什么要继承？

子类继承了父类，就可以使用父类的方法

来看个例子，了解使用继承的好处

.

这边有两个动物，一头猪 图片 一条狗 图片

猪：属性（姓名，编号），方法（吃，睡觉，叫）

狗：属性（姓名，编号） ，方法（吃，睡觉，叫）

用代码来展示：

🐖

public class Pig{ 
    private String name; 
    private int id; 
    public Pig(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"会吃饭"); 
    }
    public void sleep(){
        System.out.println(name+"会睡觉");
    }
    public void jiao() { 
        System.out.println(name+"会叫"); 
    } 
}

🐕

public class Dog{ 
    private String name; 
    private int id; 
    public Dog(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"会吃饭"); 
    }
    public void sleep(){
        System.out.println(name+"会睡觉");
    }
    public void jiao() { 
        System.out.println(name+"会叫"); 
    } 
}

可以看到这里有重复的代码，狗和猪都有相同的属性跟方法，我们就可以把他提取出来，创建一个他们公共有的父类 动物类

public class Animal{ 
    private String name; 
    private int id; 
    public Animal(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"会吃饭"); 
    }
    public void sleep(){
        System.out.println(name+"会睡觉");
    }
    public void jiao() { 
        System.out.println(name+"会叫"); 
    } 
}

这个动物类就作为他们的父类，猪跟狗就继承动物类就好了

pig类

public class pig extends Animal { 
    public pig(String myName, int myid) {  
        super(myName, myid); 
    } 
    
    public static void main(String[] args) {
        new pig("小猪",1).eat();
        new pig("小小猪",2).eat();
        new pig("小小小猪",3).eat();
    }
}

这里有一个super关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。（super直接可以来调用父类的方法，按照父类方法参数格式来传参就好了）

注意点：在java中 继承只能单一继承 ，可以多实现（implements）接口

不要杠 间接继承，孙子继承父亲，父亲继承爷爷 本质上就是单一继承

实现（实现接口有用到implement关键字）

之前我们写类 都是用class , 写接口 就要写 interface 了

来个对比：

public class A {
    public void show () {   
     //...     
    } 
}
 
public interface B {
    public void show();
}

public interface C {
    public void eat();
    public void sleep();
}
 
public class D extends A  implements B,C {
}

这边可以看到，class A 类中的方法 严格按照方法/函数语法格式 java 基础——函数（方法）

然而 接口 ，直接 分号结尾，并没有{ } ，注意区分

也可以看到，D继承了 A 实现了 B跟C 两个接口 ,体现了单一继承，多实现

来看看间接继承

public class A {
    public void show () {   
     //...     
    } 
}
 
public class B {
    public void show(int x){
    }
}


public class C extends A  extends B { 
      
}

多态

多态字面上也很好理解，一种行为，多个不同表现形式

多态的前提是有继承关系

直接来看例子：

这是一个动物类，还是一样 有能吃 的方法

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

这是一个 狗类 ，也有能吃的方法，并且继承动物类，进行方法覆盖

public class Dog extends Animal{
  //方法覆盖
  public void eat(){
    System.out.println("Dog eat ！");
  }
  //子类特有
  public void lookDoor(){
    System.out.println("看门！");
  }
}

调用看看

public static void main(String[] args)  {
        Animal animal =new Animal();
        Dog dog = new Dog();
        animal.eat();
        dog.eat();
    }

输出结果

我们还可以这样调用！！

  public static void main(String[] args)  {
        Animal animal = new Dog();
        animal.eat();
    }

输出结果：

这就是多态的体现，同一个行为（eat）作用在不同对象上,会有不同的表现结果

写在最后：

感谢您的阅读