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

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

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

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

使用编译器：IDEA

前言

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

一.封装

1.1封装的定义

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

访问修饰符	private	default	protected	public
同一包的同一类	√	√	√	√
同一包的不同类		√	√	√

不同包的子类			√	√
不同包的非子类				√

注：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();
}
}

抽象的重点知识：

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

五.接口

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();
}
}

接口的重点：

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

总结

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

Java语言-----封装、继承、抽象、多态、接口

前言

一.封装

1.1封装的定义

1.2访问修饰符的使用

二.继承

2.1继承的定义

2.2继承的方法

2.3继承使用注意点

三.多态

3,1多态的定义

3.2动态绑定

3.3方法重写

3.4向上（向下）转型

四.抽象

4.1抽象的概述和定义

4.2抽象的使用

五.接口

5.1接口的意义

5.2接口的定义

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java语言-----封装、继承、抽象、多态、接口

前言

一.封装

1.1封装的定义

1.2访问修饰符的使用

二.继承

2.1继承的定义

2.2继承的方法

2.3继承使用注意点

三.多态

3,1多态的定义

3.2动态绑定

3.3方法重写

3.4向上（向下）转型

四.抽象

4.1抽象的概述和定义

4.2抽象的使用

五.接口

5.1接口的意义

5.2接口的定义

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景