继承、修饰符、多态、抽象类、接口

最新推荐文章于 2024-09-17 11:50:15 发布
最新推荐文章于 2024-09-17 11:50:15 发布
阅读量56 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwx15230179858/article/details/130449101
版权
本文详细介绍了Java中的继承概念，包括继承的实现方式、好处与弊端，以及成员访问特点。接着讨论了抽象类和接口，它们在行为抽象中的作用，以及与类之间的关系。此外，还涵盖了多态的概念、实现条件和成员访问特点。
摘要由CSDN通过智能技术生成

继承

继承的实现

继承的概念

         继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

实现继承的格式

     继承通过extends实现 格式：class 子类 extends 父类 { } 举例：class Dog extends Animal { }

继承带来的好处

        继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

示例

public class Fu {
   public void show(){
       System.out.println("show方法被调用");
   }
}


public class Zi extends Fu {
    public void method(){
        System.out.println("method方法被调用");
    }
}



public class Damo {
    public static void main(String[] args) {
        Fu f=new Fu();
        f.show();
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

 继承的好处和弊端   

继承的好处

        提高了代码的复用性(多个类相同的成员可以放到同一个类中)

        提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

继承的弊端

        继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削 弱了子类的独立性

继承的使用

        使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承

继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则： 

        1. 子类局部范围找

        2. 子类成员范围找

        3. 父类成员范围找

        4. 如果都没有就报错(不考虑父亲的父亲…)

示例

public class Fu {
    public int age=40;
}


public class Zi extends Fu{
    public int height=175;
    public void show(){
        System.out.println(age);
        System.out.println(height);
    }
}


public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
    }
}


//输出结果为：40 175

.....................................................
public class Fu {
    public int age=40;
}


public class Zi extends Fu{
    public int height=175;
    public int age=20;
    public void show(){
        System.out.println(age);
        System.out.println(height);
    }
}

public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
    }
}

//输出结果为：20  175


.........................................................
public class Fu {
    public int age=40;
}


public class Zi extends Fu{
    public int height=175;
    public int age=20;
    public void show(){
        int age=30;
        System.out.println(age);
        System.out.println(height);
    }
}


public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
    }
}

//输出结果为：30  175

super

this&super关键字：

        this：代表本类对象的引用

        super：代表父类存储空间的标识(可以理解为父类对象引用)

this和super的使用分别

        成员变量：

                this.成员变量 - 访问本类成员变量

                super.成员变量 - 访问父类成员变量

         成员方法：

                 this.成员方法 - 访问本类成员方法

                super.成员方法 - 访问父类成员方法

        构造方法：

                this(…) - 访问本类构造方法

                super(…) - 访问父类构造方法

 

示例

public class Fu {
    public int age=10;
}


public class Zi extends Fu{
    public int age=20;
    public void show(){
        int age=30;
        System.out.println(age);
        //访问本类成员变量age
        System.out.println(this.age);
        //访问父类成员变量age
        System.out.println(super.age);
    }
}

public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
    }
}


//输出结果为：30 20 10

继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法（若子类中没有标明访问父类          哪个方法，则父类中必须有无参构造方法）

         子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化

        每一个子类构造方法的第一条语句默认都是：super()

示例

public class Fu {
    public Fu(){
        System.out.println("Fu中无参构造方法被调用");
    }
    public Fu(int age){
        System.out.println("Fu中带参构造方法被调用");
    }
}

public class Zi extends Fu{
    public Zi(){
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        System.out.println("Zi中带参构造方法被调用");
    }
}

public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        Zi z2=new Zi(20);
    }
}

//输出：Fu中无参构造方法被调用
        Zi中无参构造方法被调用
        Fu中无参构造方法被调用
        Zi中带参构造方法被调用
..................................................................

public class Fu {
    public Fu(){
        System.out.println("Fu中无参构造方法被调用");
    }
    public Fu(int age){
        System.out.println("Fu中带参构造方法被调用");
    }
}

public class Zi extends Fu{
    public Zi(){
        super();
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        super(20);
        System.out.println("Zi中带参构造方法被调用");
    }
}

public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        Zi z2=new Zi(20);
    }
}

//输出：Fu中无参构造方法被调用
        Zi中无参构造方法被调用
        Fu中带参构造方法被调用
        Zi中带参构造方法被调用

继承中成员方法的访问特点

通过子类对象访问一个方法 ：

        1. 子类成员范围找

        2. 父类成员范围找

        3. 如果都没有就报错(不考虑父亲的父亲…)

示例

public class Fu {
    public void show(){
        System.out.println("Fu中show()方法被调用");
    }
}

public class Zi {
    public void show(){
        System.out.println("Zi中method()方法被调用");
    }
}


public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

//输出：Zi中method()方法被调用
        Fu中show()方法被调用
..........................................................
public class Fu {
    public void show(){
        System.out.println("Fu中show()方法被调用");
    }
}

public class Zi {
    public void show(){
        System.out.println("Zi中method()方法被调用");
    public void show(){
        System.out.println("Zi中show()方法被调用");
    }
}


public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

//输出：Zi中method()方法被调用
       Zi中show()方法被调用
..............................................................
public class Fu {
    public void show(){
        System.out.println("Fu中show()方法被调用");
    }
}

public class Zi {
    public void show(){
        System.out.println("Zi中method()方法被调用");
    public void show(){
        super.show();
        System.out.println("Zi中show()方法被调用");
    }
}


public class Damo {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

//输出：Zi中method()方法被调用
        Fu中show()方法被调用
        Zi中show()方法被调用

super内存图

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

方法重写 

方法重写概念

        子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

方法重写的应用场景

        当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这               样，即沿袭了父类的功能，又定义了子类特有的内容

Override注解

        用来检测当前的方法，是否是重写的方法，起到【校验】的作用

示例

public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

public class NewPhone extends Phone{
    @Override
    public void call(String name){
        System.out.println("开启视频");
        //System.out.println("给"+name+"打电话");
        super.call(name);
    }
}

public class PhoneDamo {
    public static void main(String[] args) {
       Phone p=new Phone();
       p.call("林青霞");
        System.out.println("...................................");
        NewPhone np=new NewPhone();
        np.call("林青霞");
    }
}

//输出：给林青霞打电话
        ...................................
        开启视频
        给林青霞打电话

方法重写的注意事项

        私有方法不能被重写(父类私有成员子类是不能继承的)

        子类方法访问权限不能更低(public > 默认 > 私有)

示例

public class Fu {
    private void show(){
        System.out.println("Fu中show()发方法被调用");
    }
    public void method(){
        System.out.println("Fu中method()发方法被调用");
    }
}

public class Zi extends Fu {
    /*
    @Override
    private void show(){
        System.out.println("Zi中show()发方法被调用");
    }
    */
    //报错       父类中私有方法子类不能重写

    /*
    @Override
    public void method() {
        System.out.println("Zi中method()发方法被调用");
    }
    */
    //未报错

    @Override
    void method() {
        System.out.println("Zi中method()发方法被调用");
    }
    //报错   子类重写父类方法时，访问权限需大于等于父类
}
................................................................
public class Fu {
    private void show(){
        System.out.println("Fu中show()发方法被调用");
    }
    void method(){
        System.out.println("Fu中method()发方法被调用");
    }
}

public class Zi extends Fu {
    @Override
    void method() {
        System.out.println("Zi中method()发方法被调用");
    }
    //未报错
}

 Java中继承的注意事项

        Java中类只支持单继承，不支持多继承

                错误范例：class A extends B, C { }

        Java中类支持多层继承

                例：Son继承Father,Father继承Granddad,则Son同时拥有了Granddad和Father中的内容

修饰符

package

包的概念

        包就是文件夹，用来管理类文件的

包的定义格式

        package 包名; (多级包用.分开)

        例如：package com.heima.demo;

带包编译&带包运行

        带包编译：javac –d . 类名.java

        例如：javac -d . com.heima.demo.HelloWorld.java

        带包运行：java 包名+类名

        例如：java com.heima.demo.HelloWorld

import

导包的意义

        使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

        为了简化带包的操作，Java就提供了导包的功能

导包的格式

        格式：import 包名;

        范例：import java.util.Scanner;

权限修饰符

final 

fianl关键字的作用

        final代表最终的意思，可以修饰成员方法，成员变量，类

final修饰类、方法、变量的效果

        fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

        final修饰方法：该方法不能被重写

        final修饰变量：表明该变量是一个常量，不能再次赋值

final修饰局部变量

fianl修饰基本数据类型变量

        final 修饰指的是基本类型的数据值不能发生改变

final修饰引用数据类型变量

        final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

static

static的概念

        static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

static修饰的特点

        被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

        可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

static访问特点

static的访问特点

        非静态的成员方法

                能访问静态的成员变量

                能访问非静态的成员变量

                能访问静态的成员方法

                能访问非静态的成员方法

        静态的成员方法

                能访问静态的成员变量

                能访问静态的成员方法

总结：静态成员方法只能访问静态成员

多态

多态的概述

什么是多态

        同一个对象，在不同时刻表现出来的不同形态

多态的前提

        要有继承或实现关系

        要有方法的重写

        要有父类引用指向子类对象

多态中的成员访问特点

成员访问特点

        成员变量

                编译看父类，运行看父类

        成员方法

                 编译看父类，运行看子类  

示例

public class Animal {
    public int age = 40;
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
    //有父类引用指向子类对象
        Animal a = new Cat();
        System.out.println(a.age);
        // System.out.println(a.weight);
        a.eat();
        // a.playGame();
    }
}

多态的好处和弊端

好处

        提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类          型参与操作

弊端

        不能使用子类的特有成员

多态中的转型

向上转型

        父类引用指向子类对象就是向上转型

向下转型

        格式：子类型 对象名 = (子类型)父类引用;

示例

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}


public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        //向上转型
        Animal a = new Cat();
        a.eat();
        // a.playGame();
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

抽象类

抽象类的概述

        当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

        在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

抽象类的特点

        抽象类和抽象方法必须使用 abstract 关键字修饰

 

        抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

        抽象类不能实例化

                抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

        抽象类的子类

                要么重写抽象类中的所有抽象方法

                要么是抽象类

 抽象类的成员特点

成员的特点

        成员变量

                既可以是变量 也可以是常量

        构造方法

                空参构造

                有参构造

        成员方法

                抽象方法

                普通方法

示例

public abstract class Animal {
    private int age = 20;
    private final String city = "北京";
    public Animal() {}
    public Animal(int age) {
        this.age = age;
    }
    public void show() {
        age = 40;
        System.out.println(age);
        // city = "上海";
        System.out.println(city);
    }
    public abstract void eat();
}


public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

接口

接口的概述

  接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

  Java中的接口更多的体现在对行为的抽象！

接口的特点

  接口用关键字interface修饰

public interface 接口名 {}

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化

        接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。

        多态的形式：具体类多态，抽象类多态，接口多态。

接口的子类

        要么重写接口中的所有抽象方法

        要么子类也是抽象类

接口的成员特点

成员特点

        成员变量

                只能是常量 默认修饰符：public static final

        构造方法

                没有，因为接口主要是扩展功能的，而没有具体存在

        成员方法

                只能是抽象方法 默认修饰符：public abstract

        关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

示例

public interface Inter {
    public int num = 10;
    public final int num2 = 20;
    // public static final int num3 = 30;
    int num3 = 30;
    // public Inter() {}
    // public void show() {}
    public abstract void method();
    void show();
}


public class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }
    @Override
    public void method() {
        System.out.println("method");
    }
    @Override
    public void show() {
        System.out.println("show");
    }
}


public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        // i.num = 20;
        System.out.println(i.num);
        // i.num2 = 40;
        System.out.println(i.num2);
        System.out.println(Inter.num);
    }
}

类和接口的关系

类与类的关系

        继承关系，只能单继承，但是可以多层继承

类与接口的关系

        实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口与接口的关系

        继承关系，可以单继承，也可以多继承

抽象类和接口的区别

成员区别

        抽象类

                变量,常量；有构造方法；有抽象方法,也有非抽象方法

        接口

                常量；抽象方法

关系区别

        类与类

                继承，单继承

        类与接口

                实现，可以单实现，也可以多实现

        接口与接口

                继承，单继承，多继承

设计理念区别

        抽象类

                对类抽象，包括属性、行为

        接口

                对行为抽象，主要是行为

<海绵宝宝>
关注
封装、继承和多态以及抽象类和接口
m0_74500911的博客
10-23 505
本文主要说明了Java中类的封装、继承和多态的创建方法及其具体意义。
自学Java第14天：继承与多态：抽象类、接口、多态、final关键字、、权限修饰符、内容类
lhw19960418的博客
05-20 233
一、抽象类 1、抽象的概念 2、抽象方法和抽象类的定义格式 3、抽象类和抽象方法的使用 3、抽象方法和抽象类的注意事项 注意事项2 注意事项3 注意事项4 4、发红包案例 用户类 群主类 普通成员类 发红包 二、接口 1、接口概述与生活举例 2、接口的定义基本格式 3、接口的抽象方法定义 4、接口的抽象方法使用 实现类进行覆盖重写 5、接口的默认方法定义和使用 实现类A 实现类B 运行 6、接口的静态方法定义和使用 接口 实现类 7、接口的私有方法
01 static 代码块 继承 权限修饰符 多态 抽象类 接口 枚举
晨绪的博客
04-09 1114
static修饰变量修饰方法修饰代码块隶属类(静态变量)类(静态方法)类(静态代码块)推荐访问方式类名.变量名类名点.方法名()类加载时自动执行经典使用场景多对象共享变量工具类方法为类变量初始化赋值什么是继承?继承的好处是啥？继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。提高代码复用性，减少代码冗余，增强类的功能扩展性。继承的格式子类 extends 父类继承后子类的特点？
Java基础 | 继承，多态，抽象类与接口
zszq111的博客
01-12 1928
继承，多态，抽象类和接口
Java----多态+抽象类+抽象方法+接口
你好牛蛙！
02-08 2568
Java基础创作日记 Day05 时间：2021年2月7日下午 阴 昨天的前天的总结少了点东西，今天补充上 文章目录抽象+接口抽象方法抽象类接口 抽象+接口 抽象方法 当我们创建一个父类，父类的一些方法需要后代进行重写，此时父辈不需要写入任何代码，此时我们就可以把这些方法不写方法体，设置为抽象方法 语法： abstract void 方法名(); 抽象类 含有抽象方法的类必须要用abstract修饰，用abstract修饰的类叫做抽象类，抽象类可以不含有抽象方法 语法：abstract class 类名.
day01-继承&修饰符&多态&抽象类.pdf
08-23
综上所述，继承、修饰符、多态和抽象类是Java SE编程中的核心概念。继承实现了代码的复用与维护，修饰符控制了类和成员的访问权限，多态使得程序更加灵活，而抽象类为子类提供了一个共同的模板和抽象方法实现的要求...
da06抽象继承封装多态接口.zip
05-25
在Dart中，我们使用访问修饰符（如`public`，`private`，`protected`，默认访问权限）来控制成员的可见性。默认情况下，Dart的类成员对外部是可见的，但可以通过修改访问权限进行限制： ```dart class Person { ...
接口，多态，抽象类，final
08-10
"接口、多态、抽象类、final" 在 Java 编程语言中，接口、多态、抽象类和 final 是四个非常重要的概念，它们在面向对象编程（Object-Oriented Programming，OOP）中扮演着关键角色。 1. 接口 接口是 Java 中的一...
PHP入门教程之面向对象的特性分析(继承,多态,接口,抽象类,抽象方法等)
12-19
本文将深入探讨PHP中的面向对象特性，包括继承、多态、接口、抽象类和抽象方法等核心概念。 1. **继承（Inheritance）** 继承允许我们创建一个新类，该类继承自一个已存在的类（父类或基类）。这意味着子类将自动...
Java-网络
2301_81543552的博客
09-14 701
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 612
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 285
【代码】自动生成不重复的订单id。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 707
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1143
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 650
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
Gradle
xiaocaij_icai的博客
09-15 193
");
Java8的Optional简介
最新发布
duke_ding2的博客
09-17 527
Java8的Optional简介
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
weixin_48278764的博客
09-14 1172
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 944
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Java面向对象编程之继承、修饰符、多态和抽象类
Java 中的继承、修饰符、多态和抽象类 Java 中的继承是一种机制，允许一个类继承另一个类的成员变量和成员方法，从而提高代码的复用性和维护性。继承的实现方式是通过 extends 关键字来实现的，例如：`class 子类 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值