面向对象（继承与抽象）

最新推荐文章于 2024-05-11 10:24:57 发布

BoatsZhou

最新推荐文章于 2024-05-11 10:24:57 发布

阅读量54

点赞数

分类专栏： Java笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33254911/article/details/132191557

版权

Java笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

继承

继承概述

多个类中存在相同的属性和行为，将这些内容抽取到单独的一个类中，这个类就是父类，那么多个子类无需再定义这些属性和行为，只需要继承那个父类即可。

在这里插入图片描述

其中，多个类可以称为子类，单独那一个类称为父类、超类或基类。

继承概念

就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性，相同的行为。
子类可以直接访问父类中非私有的属性和行为

继承的特点

子类自动拥有父类非私有的成员
子类也可以拥有自己的成员

继承的好处

提高代码的复用性
类与类之间产生了关系，这是多态的前提

继承的格式

通过extends关键字，可以声明一个子类继承另一个父类

格式

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

继承中成员访问的特点

子类访问父类私有成员

public class Father {

    //私有的成员变量
    private int num = 10;
    public int num2 = 20;

    //私有的成员方法
    private void mothod(){
        System.out.println(num);
        System.out.println(num2);
    }

    public void show(){
        System.out.println(num);
        System.out.println(num2);
    }
}


public class Son extends Father {

    //子类也可以有自己的东西
    public void function(){

        //子类不能访问父类中私有的成员变量
        // System.out.println(num);

        System.out.println(num2);

    }
}


public class SonTest {
    public static void main(String[] args) {

        Son s = new Son();
        // s.num =200; //子类不能访问父类中的私有的成员变量
        s.num2 = 100;

        // s.mothod(); //子类不能访问父类中的私有的成员方法
        s.function(); //也可以访问自己的方法
        s.show();

    }
}

成员变量

成员变量不重名

如果子类父类中出现的成员变量没有重名，这时的访问是没有影响的

//父类
public class Father {
    int num = 10;
}

//子类
public class Son extends Father {
    //子类成员变量
    int num2 = 20;
    
    //子类成员方法
    public void function(){
        // 访问父类中的num，
        System.out.println("Fu num="+num); //10    

        // 访问子类中的num2
        System.out.println("Zi num2="+num2); // 20
    }
}

//测试类
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.function();
    }
}

成员变量重名

如果子类父类中出现重复的变量名，这时候访问是有影响的。

//父类
public class Father {
    int num = 10;
}

//子类
public class Son extends Father {
    int num = 20;
    //子类成员方法
    public void function(){
        //如果子类成员变量的名与父类成中变量名一样，就近原则
        System.out.println("num="+num); //20    
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {

        Son s = new Son();
        s.function();

    }
}

子类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super关键字，修饰父类成员变量

使用格式
```
super.父类成员变量名
```

代码演示

public class Son extends Father {

    int num = 20;

    //子类成员方法
    public void function(){
        //如果子类成员变量的名与父类成中变量名一样，就近原则
        // System.out.println("Fu num="+num); //20    

        //我就想访问父类中的成员变量，怎么办？  用super
        System.out.println(super.num);//此时访问的就是父类的成员变量 10

    }
}

注意
父类中的成员变量是非私有的，子类中可以直接访问。若父类中的成员变量私有了，子类是无法直接访问的。

成员方法

成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

//父类
public class Father {
    public void show(){
        System.out.println("我是父类Father");
    }
}

//子类
public class Son extends Father {
    public void show2(){
        System.out.println("我是子类Father");
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {

        Son s = new Son();
        s.show();//调用父类方法

        s.show2();//调用子类方法
    }
}

方法重写

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写（Override）

什么是方法重写？
子类和父类中出现一模一样的方法时（返回值类型相同，方法名相同，参数列表相同），会出现覆盖效果，也成为重写或复写。声明不变，重新实现。

//父类
public class Father {

    public void show(){
        System.out.println("我是父类Father");
    }

    public void method(){
        System.out.println("我是父类method");
    }
}
//子类
public class Son extends Father {

    public void show2(){
        System.out.println("我是子类Father");
    }

    public void method(){
        System.out.println("我是子x`类method");
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {

        Son s = new Son();
        s.show();//调用父类方法
        s.show2();//调用子类方法
        System.out.println("===================");
		
        //方法重写：子类中出现了与父类中的一模一样的方法
        //子类重写了父类的方法
        s.method();
    }
}

方法重写的应用场景

子类可以根据需要，定义特定属于自己的行为，既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强

方法重写的注意事项

子类方法重写父类方法，必须要保证权限大于等于父类权限，最好修饰权限一样
子类方法重写父类方法，返回值类型，方法名和参数列表都要一模一样

构造方法执行特点

描述

构造方法的名字是与类名一致的。所有子类是无法继承父类构造方法的。
构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

//父类
public class Father {
    private int num;
    //父类的构造方法
    public Father(){
        System.out.println("父类的构造方法");
    }
    public Father(int num) {
        this.num = num;
    }
    public void show1(){
        System.out.println(num);
    }
}

//子类
public class Son extends Father {
    //子类无参构造方法
    public Son(){
        // 子类构造方法中的第一行默认有 super() ,给父类进行初始化的
        // 作用：因为继承必须先调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
        super();
        System.out.println("子类的构造方法");
    }
    //子类有参构造方法
    public Son(int num2) {
        super(34);
        this.num2 = num2;
    }

    public void show2(){
        System.out.println(num2);
    }
    
}

//测试
public class Test {
    public static void main(String[] args) {
        //在每次创建子类对象时，都会先初始化父类构造方法，再创建其子类对象本身。
        Son s = new Son();
        Son s = new Son();//每一次实例子类对象，都会先访问父类的无参构造  （这里两次）
        
        //访问有参构造
        Son s = new Son(2000);
        s.show1();
        s.show2();
    }
}

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

访问构造方法的注意事项

在子类构造方法中的第一行默认有 super() ,给父类进行初始化的
在子类构造方法中可以手动调用父类其他重载的构造方法
格式: super(参数列表);
super 是写在子类的构造方法的第一行

注意

【super.父类成员方法】，表示调用父类的成员方法
【super.父类成员变量名】，表示调用父类的成员变量
【super()】,表示访问父类中的无参构造
【super(参数列表)】, 表示访问父类中的有参构造

super和this

super和this的含义

super：前提要有继承关系，代表父类的存储空间标识（可以理解为父类的引用）
this：代表当前对象的引用。

super和this的用法

访问成员

this.成员变量       ‐‐    本类的
this.成员方法名()    ‐‐    本类的    
    
super.成员变量      ‐‐    父类的
super.成员方法名()   ‐‐    父类的

访问构造方法
```
this(...)       ‐‐    本类的构造方法
super(...)      ‐‐    父类的构造方法
```
子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super()和this()都必须是在构造方法的第一行，所以不能同时出现。

super和this的区别

super的用法，前提：一定要有继承关系，子类无法访问父类的成员，通过super关键字来找父类引用
$\quad\quad$ super.成员变量子类访问的父类中的成员变量
$\quad\quad$ super.成员方法子类访问的父类中的成员方法
$\quad\quad$ super() 子类访问父类的无参构造方法
$\quad\quad$ super(“xx”) 子类访问父类中有参构造方法
this的用法代表当前对象的引用（谁调用this就代表谁）
$\quad\quad$ this.成员变量本类的成员变量
$\quad\quad$ this.成员方法本类的成员方法

继承的特点

/*
	Java中继承的特点：
		A:Java只支持单继承，不支持多继承。
			有些语言是支持多继承，格式：extends 类1,类2,...
		B:Java支持多层继承(继承体系),间接继承
*/

class Father(){}
class Mother(){}

class son extends Father(){} // 正确
class son2 extends Father , Mother {} // 不正确

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

//一个类只能有一个父类，不可以有多个父类。
class C extends A{}     //ok
class C extends A，B...  //error

Java支持多层继承

class A{}
class B extends A{}
class C extends B{}

子类和父类是一种相对的概念
一个父类可以有很多个子类

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class Pig extends Animal{}

抽象类

什么是抽象

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
父类中的方法应该不是具体的，具体的实现应该有子类来实现；但是父类中的方法一定是具有共性的方法

什么是抽象方法

只有方法的声明，没有方法体的方法
什么是抽象类

抽象方法所在的类一定是抽象类

抽象类和抽象方法的格式

抽象方法

使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式

修饰符 abstract 返回值类型 方法名 (参数列表);

演示
```
public abstract void run();
```

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类

定义格式
```
public abstract class 类名字 {...}
```

演示

public abstract class Animal{
	public abstract void eat();
}

抽象的使用

具体的子类继承抽象的父类必须重写父类所有的抽象方法
抽象的子类继承抽象的父类，不用再去重写父类的所有抽象方法，这种是没有意义

/**
 * @Desc: 抽象类中可以有抽象方法，也可以有非抽象方法
 *        有抽象方法的类，这类一定是一个抽象类
 */
public abstract class Animal {

    //抽象类有构造方法吗？ 有
    public Animal(){}

    //抽象类可以实例化 不能

    /**
     * 抽象方法一定是共有，只不过每个子类实现的方式不一样
     */
    public abstract void eat();

    public abstract void run();

    public void show(){
        System.out.println("我是动物中show方法");
    }
}

/**
 * @Desc:  子类如果是一个具体的类，必须重写父类中所有抽象方法
 */
public class Cat extends Animal {

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

    @Override
    public void run() {
        System.out.println("猫走猫步");
    }
}

/**
 * @Desc:  子类如果是抽象的，不需要重写父类中的抽象方法
 */
public abstract class Dog extends Animal {
}

/**
 * @Desc:  如果子类继承抽象类，抽象类中有抽象方法必须要重写，有非抽象方法，直接继承
 */
public class CatTest {
    public static void main(String[] args) {

        //抽象类本身是不可以实例化
        // Animal an = new Animal();

        Cat c = new Cat();
		//重写抽象类中的方法
        c.eat();
        c.run();
        //直接继承过来的show方法
        c.show();
    }
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

抽象的注意事项

有抽象方法的类，这个类一定是抽象类
抽象类中可以有抽象方法，也可以有普通方法
抽象类有没有构造方法有
抽象类是否可以实例化不能
抽象类中的普通方法如何调用，能过子类继承过来即可调用

抽象类关键字使用

abstract不能和以下关键字一块使用

private 冲突
final 冲突
static 冲突

public abstract class Fu {

    //非法的修饰符组合
    // private abstract void show();

    //非法的修饰符组合
    // final abstract void method();

    //非法的修饰符组合
    // static abstract void method();

    //可以有静态方法
    public static void method1(){
        System.out.println("method1");
    }

}

BoatsZhou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
面向对象（继承与抽象）

多个类中存在相同的属性和行为，将这些内容抽取到单独的一个类中，这个类就是父类，那么多个子类无需再定义这些属性和行为，只需要继承那个父类即可。其中，多个类可以称为子类，单独那一个类称为父类超类或基类。父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。父类中的方法应该不是具体的，具体的实现应该有子类来实现；
复制链接

扫一扫