😽个人主页： tq02的博客_CSDN博客-C语言,Java领域博主

🌈理想目标：努力学习，向Java进发，拼搏一切，找到一份朝九晚五，有假期的工作，让自己的未来不会有遗憾。

🎁欢迎各位→点赞👍 + 收藏⭐ + 评论📝+关注✨

    本章讲解内容：Java封装、继承、抽象、多态、接口

     使用编译器：IDEA

前言    

        在讲述封装、继承、抽象、多态、接口前，我们得先了解一下，什么是类与对象，类与对象的详细讲解：tq02的类与对象讲解

一.封装

1.1封装的定义

封装，在类里操作，将类的成员变量和成员方法进行封装处理，意义：可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。而对类进行封装我们需要使用访问修饰符，一共分为四种，

注：1.如果成员变量或者成员方法没有使用封装则是默认使用default修饰符。

        2.包是存放多个类的容器，就是防止在工程建立时，和其他人写的类名相同而起冲突。

        3.子类是在继承当中可以学到的。

1.2访问修饰符的使用

  我们进行四种封装代码实例图

1.private修饰

private修饰的price和name变量，其他类无法访问，只有自己的类里可以进行访问。就例如在BookList类里无法直接访问这两个元素变量。

2.default修饰

default修饰符，是指当你没有标注修饰符时，就默认了default修饰符，而此类的只有同一个包的其他类访问，例如BookList可以访问，但不同包的Student类无法访问。

3.protected修饰符

protected修饰符，类当被修饰了之后，同包下所有的类都可以访问，非同包下的其他包的子类也可以使用。如Student类继承之后也可以使用Book类。

4.public修饰符

public修饰符，一旦使用，所有的类都可以使用，不在乎是否同包。

二.继承

2.1继承的定义

继承是什么？是所有OOP语言不可缺少的组成成分，是面向对象的三大特征之一，继承就相当于，孩子继承父亲的东西（父亲愿意给孩子的东西），关键字是extends，继承父类的成员变量和成员方法，一般是为了减少代码冗余。但是继承也得遵守访问修饰符，一旦不符合，则无法继承。

代码显示：

public class Animal {
    public String name;
    public Animal(String name) {
    this.name = name;
    }
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
}
}
// Cat.java
class Cat {
    public String name;
    public Cat(String name) {
    this.name = name;
    }
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
}
}
// Bird.java
class Bird {
    public String name;
    public Bird(String name) {
    this.name = name;
    }
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
    }
    public void fly() {
    System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}

可以看得出来，Animal类和cat类还有Bird类，有很多重复的代码，而为了减少大量的冗余代码，我们可以使用继承的手段。

2.2继承的方法

定义方法：

class 子类 extends 父类 {

}

代码实现：

class Animal {
    public String name;
    public Animal(String name) {
    this.name = name;
}
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
    // 使用 super 调用父类的构造方法.
    super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
    super(name);
}
    public void fly() {
    System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}
public class Test {
    public static void main(String[] args) {
    Cat cat = new Cat("小黑");
    cat.eat("猫粮");
    Bird bird = new Bird("圆圆");
    bird.fly();
}
}

我们可以看出，Cat类和Bird类的成员变量和成员方法相当于是在Animal类的基础上，扩展出来。

2.3继承使用注意点

使用 extends 指定父类.

Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

子类会继承父类的所有 public 的变量和方法.

对于父类的 private 的字段和方法, 子类中是无法访问的.

子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

所有的类都有一个父类---Object类

三.多态

3,1多态的定义

       多态是面向对象三大特征最后一个，可以增强程序的扩展性，提高程序的可维护性。而它的主要支撑技术有向上转型、向下转型、动态绑定、方法重写。

3.2动态绑定

         即方法与方法的主体在运行时才进行绑定。例如，当父类和子类拥有一个同名的方法（remove），那么定义了an.remove()，remove方法的调用主体是an，但是an只有调用时，才能知道是实例化了哪个类。而这便是动态绑定。

3.3方法重写

       当子类和父类的成员方法名相同时，那么子类的成员方法便是方法重写。而当子类的对象实例化之后，使用和父类同名的方法，则使用的子类的方法，不是使用父类的方法。

class Animal {
    public String name;
    public void Name(String name) {
     System.out.println("Animal的名字是"+name);
}
}
class Cat extends Animal {
      public void Name(String name) {
     System.out.println("Cat的名字是"+name);
}
}
public class Test {
    public static void main(String[] args) {
   Cat cat = new Cat();
   cat.Name("小黑");
}
}

该代码的结果是Cat的名字是小黑，由此可见，使用的Cat类的Name方法，而不是Animal类的Name方法。

3.4向上（向下）转型

向上转型和向下转型都是在继承的基础上

class Animal {
    public String name;
    public Animal(String name) {
    this.name = name;
}
}
class Cat extends Animal {
    public int age;
    public Cat(String name) {
    // 使用 super 调用父类的构造方法.
    super(name);
    }
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
    }
}
public class Test {
    public static void main(String[] args) {
    Animal cat = new Cat("小黑");
   cat.eat();
}
}

从上面代码中，我们可以发现cat是Animal的引用变量，而它指向了子类的对象，这就是向上转型。

注：

cat是Animal类型的引用变量，而对于Animal类型的引用变量来说，是无法得知age子类成员变量的，所以无法使用cat.age=22;进行赋值的。

由于cat实际上指向Cat的对象，所以当调用eat()方法时；依然还能显示子类成员方法的信息。

public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println("我是一只小动物");
        System.out.println(this.name + "正在吃" + food);
    }
}
public class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void eat(String food) {
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    }
    public void fly() {
        System.out.println(this.name + "正在飞");
    }
    public static void main(String[] args) {
        Animal animal = new Bird("圆圆");
        //强制转换为Bird类型
          Bird bird = (Bird)animal;
          bird.fly();
    }
}

从上面代码中，我们可以很明显的发现向下转型需要通过强制类型转换完成。虽然animal是Animal父类的引用变量，但是将animal强制转换为Bird类型便为向下转型。但是并不安全，因为向下转型可能会不正确，例如原本向下转型为Cat类，但却转型为了Bird类，这便会产生危险性。

解决方法：

Animal animal = new Cat("小猫");
if (animal instanceof Bird) {
Bird bird = (Bird)animal;
bird.fly();
}

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。

结论：1.向上转型时，是父类的引用变量指向了子类的对象，当然，无法使用子类的新增成员（变量和方法），但是如果使用父类的成员方法，如果子类有该方法的重写，则使用重写的方法，若无，则使用父类方法。

       2.向下转型时，则需要强制类型转换。

四.抽象

4.1抽象的概述和定义

抽象类，关键字为abstract，如果所有的子类都要重写父类的某个方法时，父类的方法可以为抽象方法，直接声明，不需要结构体。而含有抽象方法的类，则为抽象类

定义方法：

              public abstract  类名{

               String name;

               public abstract void 方法名();

}

4.2抽象的使用

       抽象类存在的最大意义就是为了被继承.

        抽象类不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。

abstract class  Animal {
    public String name;
    public Animal(String name) {
    this.name = name;
}
    public abstract void eat(String food); //抽象方法，子类一定要重写
}
class Cat extends Animal {
    public Cat(String name) {
    // 使用 super 调用父类的构造方法.
    super(name);
   //重写父类的抽象方法
   public abstract void eat(String food){
     System.out.println("猫吃"+food);
    }
    }
}
class Bird extends Animal {
    public Bird(String name) {
    super(name);
}
   //重写父类的抽象方法
    public abstract void eat(String food){
     System.out.println("鸟吃"+food);
    }
}
public class Test {
    public static void main(String[] args) {
    Cat cat = new Cat("小黑");
    cat.eat("猫粮");
    Bird bird = new Bird("圆圆");
    bird.fly();
}
}

抽象的重点知识：

1. 抽象类不能直接实例化。
2. 抽象方法不能是 private 的。
3. 抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用。

五.接口

5.1接口的意义

接口是为了弥补代码无法多继承，只能单继承的问题。例如定义了一个Animal的父类，和Cat、Bird、Dog、Wolf的子类，可是你想啊，狗和猫是宠物，或许有共同的方法，定义一个宠物类，那么可以通过接口实现不相关类的相同行为。

好处：

利于代码的规范，目的是给开发人员一个清晰的指示，告诉他们哪些业务需要实现；同时防止由于开发人员随意命名而导致命名不清晰和代码混乱，影响开发效率。

是有利于对代码进行维护，定义一个接口，把功能菜单放在接口里，然后定义类时实现这个接口。

是保证代码的安全和严密。

5.2接口的定义

定义方法：

        public interface  接口名{ }

使用接口：

       class  类名   implements  接口名{ 方法体 }；

代码实现：

class Animal {
    public String name;
    public Animal(String name) {
    this.name = name;
    }
}
   //定义接口
public interface Eat {
     public void eat(String food);
}
                      //使用接口
class Dog extends Animal implements Eat{
    public int age;
    public Cat(String name) {
    // 使用 super 调用父类的构造方法.
    super(name);
    }
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
    }
}
                        //使用接口
class Cat extends Animal implements Eat{
    public int age;
    public Cat(String name) {
    // 使用 super 调用父类的构造方法.
    super(name);
    }
    public void eat(String food) {
    System.out.println(this.name + "正在吃" + food);
    }
}
public class Test {
    public static void main(String[] args) {
    Animal cat = new Cat("小黑");
   cat.eat();
}
}

接口的重点：

1. 接口的方法体若为空，则为空实现。
2. 一个类可以有多个接口。
3. 接口里所有的方法都是public和抽象的，所以可以省略public和抽象的。
4. 接口无法被实例化。
5. 接口可以被继承

总结

     继承是多态、抽象的基础，而学会了抽象，才能理解接口。而这些知识都是Java最为重要的面向对象三大特征的。只有细心学习，才能更近一步，在Java上才能算正式起步。