首页 > 其他分享 >面向对象--继承

面向对象--继承

时间：2023-08-20 16:00:46浏览次数：37  
标签：-- 子类 继承 class 面向对象 void 父类 方法 public

继承概述

在面向对象里面，继承是对类进一步抽象的过程。当多个类中存在相同属性和行为时，将这些相同属性和行为抽取到单独一个类中,这个类就是父类，子类无需再定义这些属性和行为，只要继承父类即可。其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者*基类*。

继承概念

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

继承的特点

  • 子类自动拥有父类非私有的成员(成员变量、成员方法)
  • 子类也可以拥有自己的成员

继承的好处

  • 提高代码的复用性，降低重复代码；
  • 有了继承，类与类之间产生了关系，是多态的基础。

继承的格式

通过extends 关键字，声明一个子类继承另外一个父类，定义格式如下： 

class 父类 { ... }
class 子类 extends 父类 { ... }
代码演示
//父类
public class Person {
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

//子类
public class Student extends Person { }

/*
 * 定义测试类
 */
public class PersonTest {
    public static void main(String[] args) {        
        Student s = new Student();
        s.eat();
        s.sleep();
    }
}

继承中成员访问的特点

子类访问父类非私有成员

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.mothod(); //子类不能访问父类中的私有的成员方法
        s.num2 = 100;
        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);

    }
}
注意

父类中的成员变量是非私有的，子类中可以直接访问。若父类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，并在父类中提供公共的getXxx方法和setXxx方法。

成员方法

成员方法不重名

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

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

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

//测试
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();//调用父类方
        s.show2();//调用子类方法
    }
}

方法重写(Override))

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

什么是方法的重写

方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。

代码演示
//父类
public class Father {
    public void method(){
        System.out.println("父类方法");
    }
}
//子类
public class Son extends Father {
    public void method(){
        System.out.println("子类方法");
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        //方法重写：子类中出现了与父类中的一模一样的方法
        //子类重写了父类的方法
        s.method();
    }
}

方法重写的应用场景

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

方法重写的注意事项

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

构造方法执行特点

描述

1.构造方法的名字是与类名一致的。子类无法继承父类构造方法。

2.构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个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();
        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修饰，则子类可以随意使用父类成员。

访问构造方法的注意事项

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

【super.父类成员方法】，表示调用父类的成员方法

【super.父类成员变量名】，表示调用父类的成员变量

【super()】,表示访问父类中的无参构造

【super( 88 )】, 表示访问父类中的有参构造

super和this

super和this的含义

  • super：前提：继承关系 。代表父类的存储空间标识
  • this：代表当前对象的引用(谁调用就代表谁)。

super和this的用法

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

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super()和this()都必须是在构造方法的第一行，所以不能同时出现。

super和this的区别？

super的用法
前提：一定要有继承关系，子类无法访问父类的成员，通过super关键字来找父类引用
    super.成员变量     子类访问的父类中的成员变量
    super.成员方法     子类访问的父类中的成员方法    
    super()            子类访问父类的无参构造方法
    super("xx")        子类访问父类中有参构造方法

this的用法    代表当前对象的引用（谁调用this就代表谁）
    this.成员变量      本类的成员变量
    this.成员方法      本类的成员方法

继承的特点

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{}

代码演示

//爷爷
public class GrandFather {
    public void show(){
        System.out.println("爷爷");
    }
}
//父亲
public class Father extends GrandFather {
    public void method(){
        System.out.println("父亲");
    }
}
//儿子
public class Son extends Father { }

//测试
public class Test {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();// 间接的继承爷爷的方法
        s.method();//继承了父亲的方法
    }
}

抽象类

什么是抽象

抽象：就是从具体到概念化的过程；

什么是抽象方法

只有方法的声明，没有方法体{}的方法，就是抽象方法

什么是抽象类

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

抽象类和抽象方法的格式

抽象方法

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

定义格式

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

抽象类

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

定义格式

public abstract class 类名字 {   
}
public abstract class Animal {
    public abstract void run();
}

抽象的使用

具体的子类继承抽象的父类必须重写父类所有的抽象方法

抽象的子类继承抽象的父类，不用再去重写父类的所有抽象方法

代码演示

public abstract class Animal {

    public Animal(){}

    public abstract void eat();

    public abstract void run();

    public void show(){
        System.out.println("动物类中show方法");
    }
}
public class Cat extends Animal {

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

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

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

        //抽象类本身是不可以实例化
        // Animal an = new Animal();
        Cat c = new Cat();
        //重写抽象类中的方法
        c.eat();
        c.run();
        //直接继承过来的show方法
        c.show();
    }
}

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

抽象的注意事项

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

抽象类关键字使用

abstract不能和以下关键字一块使用
private 冲突
final 冲突
static 冲突


标签：--,子类,继承,class,面向对象,void,父类,方法,public
From： https://blog.51cto.com/u_16228964/7162296

相关文章

  • 绪论
    1.概念：  数据：统称---------------------------------------------------------------------------qq所有的数据  数据元素：可细分的数据整体----------------------------------------------------一个qq账号  数据项：数据元素的一项-------------------------------......
  • 「twcms插件」取随机内容标签
    1、把附件解压，放到twcms\block文件下面。2、调用方法{block:rand mid="2"}{loop:$data[list] $v}<p><a href="{$v[url]}">{$v[subject]}</a></p>{/loop}{/block}不传递参数mid，默认为2(读取文章)默认随机5条，可以定义参数limit="10"......
  • C++ 变量初始化总结
    堆空间，new操作初始化1、对于有自己写构造函数的类，不论类型名后面有没有括号()或者数组[]，都用构造函数进行初始化,如果构造函数delete，则编译报错；2、如果没有构造函数，则不加括号的new只分配内存空间，不进行内存的初始化，3、而加了括号()的new会在分配内存的同时初始化为0。栈空间......
  • TWCMS实现遍历所有频道及下面的分类
    $cate_arrs=$run->category->find_fetch();foreach($cate_arrsas$v){if($v['upid']==0){$v['flist']=$run->category->find_fetch(array('upid'=>$v['cid']));$parrs[]=$v; } } //hookkp_block_listeac......
  • 1.8.21二维数组右上左下遍历
    1.题目描述给定一个row行col列的整数数组array，要求从array[0][0]元素开始，按从左上到右下的对角线顺序遍历整个数组。输入输入的第一行上有两个整数，依次为row和col。余下有row行，每行包含col个整数，构成一个二维整数数组。（注：输入的row和col保证0<row<100,0<col<100）输......
  • TWCMS文章列表添加数字序列号
    如原来列表为:TWCMS怎样获取当前文章的分类名称TWCMS实现遍历所有频道及下面的分类TWCMS禁止评论昵称和内容中包含网址的解决办法通过修改.htaccess批量实现网站内页301重定向跳转需要变成为1.TWCMS怎样获取当前文章的分类名称2.TWCMS实现遍历所有频道及下面的分类3.TWCMS......
  • 浮躁-创业互联网公司第一大杀手
    在当今互联网创业的浪潮中，许多初创公司都面临着浮躁的问题，这也成为了他们最大的杀手之一。浮躁往往导致公司失去理性思考和长远规划，过于追求眼前的快速成功而忽视了潜在的风险和挑战。因此，我们认为创业公司应该保持冷静、理性，并且注重发展长期的可持续性战略。只有这样，才能够在激......
  • TWCMS的SEO标题标签调用优化代码
    做SEO的朋友都有一个习惯，那就是用SEO标题，很多人不知道，其实TWCMS是支持的，只是很多人不知道，今天就给大家讲一下TWCMS标题SEO标签调用优化代码，网站title标签默认主题为<title>{$tw[titles]}</title>如果我们单独设置了某些分类、单页以及文章的SEO标题，要区分这些单独设置了的SEO......
  • MySQL中查询和事务的大小
    有时候了解事务的大小非常重要，尤其是当计划迁移到HA环境，为了保证集群的最佳性能，事务的大小是有限制的。这里来尝试分析一下了解事务大小的不同方法。首先要将事务分成两种类型：1.生成数据的事务(写操作，比如insert、delete、update等DML操作)2.只读的事务(查询操作)在HA环境，第一......
  • TWCMS编辑器Ueditor超链接添加nofollow属性
    打开ueditor目录再进入dialogs/link目录，编辑link.html<tr><tdcolspan="2"><labelfor="target"><varid="lang_input_target"></var></label>inputid="target"type="checkbox"/>&......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99