首页 / JAVA / java基础——day07-1 继承、super、this、抽象类

java基础——day07-1 继承、super、this、抽象类

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java基础——day07-1 继承、super、this、抽象类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10581字，纯文字阅读大概需要16分钟。

内容图文

java基础——day07-1 继承、super、this、抽象类

继承

概述

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

例如：生活中的继承

java基础——day07-1 继承、super、this、抽象类 - 文章图片

　　从图中，我们可以了解到，兔子和羊属于食草类动物，狮子和豹子属于食肉类动物，而食肉动物和食草动物又属于动物类

　　其中，多个类可以称为子类，单独那一个类成为父类、超类（superclass）或者基类

java基础——day07-1 继承、super、this、抽象类 - 文章图片

定义

　　继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性（成员变量）、相同的行为（成员方法）。子类可以直接访问父类中的非私有的属性和行为。（例如父亲的姓名、父亲会打球你不能继承）

好处

　　1、提高代码复用性

　　2、类与类之间产生了关系，是多态的前提

继承的格式

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

　　 java基础——day07-1 继承、super、this、抽象类 - 文章图片

　　演示：

package day07.demo01;
//父类 -- 员工
public class Employee {
    //定义员工类
    //成员变量
    String name;
    int age;
    //成员方法
    public void work(){
        System.out.println("方法执行");
    }
}

定义一个父类-员工

package day07.demo01;
//定义了一个员工的子类：教师 其继承父类 extends
public class Teacher extends Employee {

}

定义教师类继承员工类 java基础——day07-1 继承、super、this、抽象类 - 文章图片

package day07.demo01;

public class Assistant extends Employee {
    //定义员工的另一个子类 -助教

}

定义员工第二个子类--助教 java基础——day07-1 继承、super、this、抽象类 - 文章图片

package day07.demo01;

/**
 * 子类就是父类 is-a 教师就是员工
 */
public class day07_1 {

    public static void main(String[] args) {
        //创建子类对象
        Teacher teacher = new Teacher();
        //子类继承了父类"工作"的成员方法
        teacher.work();
        //创建员工另外一个对象--助教
        Assistant assistant = new Assistant();
        //助教调用员工（父类）的工作（成员）方法
        assistant.work();
    }
}

main函数

　　特点：提高代码的复用性

　　关系：is -a

　　 java基础——day07-1 继承、super、this、抽象类 - 文章图片

继承后的特点——成员变量

1.成员变量不重名

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

package day07.demo01.demo02;

public class Fu {
    //创建父类成员变量
    int numFu = 10;
}

package day07.demo01.demo02;
//创建子类—Zi 继承父类—Fu
public class Zi extends Fu {
    //定义子类的成员变量
    int numZi = 20;
    /**
     * 此处子类含有两个成员变量
     * 一个是自己定义的numZi
     * 一个是继承Fu的numFu
     */

}

package day07.demo01.demo02;

public class demo01 {
    public static void main(String[] args) {
        //创建一个父类对象
        Fu fu = new Fu();
        System.out.println(fu.numFu); //只能使用父类的东西，没有任何子类的东西
        //创建一个子类对象
        Zi zi = new Zi();
        System.out.println(zi.numFu);//可以访问父类的成员变量
        System.out.println(zi.numZi);//也可以访问自定义的成员变量

    }
}

main

2.成员变量重名

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

package day07.demo01.demo03;

public class Fu {
    int num = 10;
    public void methodFu(){
        //访问的是父类中的num
        System.out.println("fu："+num);
    }
}

package day07.demo01.demo03;
//创建子类—Zi 继承父类—Fu
public class Zi extends Fu {
    int num = 20;
    public void methodZi(){
        //访问的是子类的num  因为num里面有
        System.out.println("zi："+num);
    }
    public void show(){
        //访问父类中的num
        System.out.println("子类访问父类的num："+super.num);
        //访问子类自己的num
        System.out.println("子类访问自己的num："+this.num);
    }
}

package day07.demo01.demo03;

/**
 * 子父类成员变量重名情况
 * 直接：等号左边是谁，没有则向上找
 * 间接：该方法属于谁 就优先用谁 没有则向上找
 */
public class demo {
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.methodFu();
        Zi zi = new Zi();
        System.out.println(zi.num); //直接访问子类 子类优先 20 没有则找父类的
        zi.methodZi();
        System.out.println("---------------------");
        zi.show();

    }
}

main

　　注意：子父类出现同名成员变量时，在子类中访问父类中非私有成员变量时，要使用super关键字，修饰父类成员变量，类似与this关键字。

　　使用格式：super.父类成员变量名(子父类同名变量名)

3.访问private修饰的父类成员变量

　　当使用private（私有）修饰父类成员变量，那么如何访问父类私有成员变量？

package day07.demo01.demo04;

public class Fu {
    //使用private修饰父类成员变量
    private String name = "张若筠";
    private int age = 28;
    //这时需要通过get and set方法访问
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package day07.demo01.demo04;
//子类继承父类
public class Zi extends Fu {

    public void show(){
        //访问父类的Name成员变量（属性）
        System.out.println(this.getName());
        //访问父类的name成员变量（属性）
        System.out.println(this.getAge());
    }
    public void setFu(){
        //修改父类的姓名属性（一般不建议）
        this.setName("海燕");
        this.setAge(40);
    }


}

package day07.demo01.demo04;

public class demo {
    public static void main(String[] args) {
        //创建一个子类对象
        Zi zi = new Zi();
        //调用子类访问父类的成员方法
        zi.show();
        //调用子类修改父类的成员方法
        zi.setFu();
        //打印修改后的父类
        zi.show();
    }
}

main

　　我们可以通过getter and setter去访问父类的私有成员变量，但是关于setter要根据事情进行添加

继承后的特点——成员方法

1.成员方法不重名

　　如果子类和父类中出现不重名的成员方法，这时调用不会有影响

package day07.demo01.demo05;

public class Fu {
    //子父类成员方法不重名
    public void method(){
        System.out.println("我是父类中的成员方法");
    }
}

package day07.demo01.demo05;
//继承
public class Zi extends Fu{
    public void methodZi(){
        System.out.println("我是子类中的成员方法");
    }
}

package day07.demo01.demo05;
//子类和父类的成员方法 不重名
public class demo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        //子类调用父类的成员方法
        zi.method();
        //子类调用自己的成员方法
        zi.methodZi();
    }
}

main

2.成员方法重名——重写（override）

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

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

　　特点：创建的是子类对象，则优先用子类方法（创建的是父类对象则优先用父类的方法）　

package day07.demo01.demo06;

public class Fu {
    //创建父类的成员方法
    public void method(){
        System.out.println("我是父类中的方法");
    }
}

package day07.demo01.demo06;
//继承
public class Zi extends Fu {
    //定义子类中的成员方法 方法重写
    public void method(){
        System.out.println("我是子类中的成员方法--override");
    }
}

package day07.demo01.demo06;

public class demo {
    public static void main(String[] args) {
        //创建一个子类对象
        Zi zi = new Zi();
        //特点：创建的是子类对象，所以优先选择子类的方法 所以输出override
        zi.method();
        //创建一个父类对象
        Fu fu = new Fu();
        fu.method(); // 创建的是一个父类对象 优先选择父类的方法
    }
}

main

　　对比：

　　方法重写(override)：发生在继承关系中，方法名称一样，参数列表也一样

　　方法重载(overload)：方法名称一样，参数列表不一样

重写的应用（完善父类的缺陷）

　　子类可以根据需求，定义特定自己的行为。比如手机增加来电显示头像的功能

package day07.demo01.demo07;
//创建手机 父类
public class phone {
    //创建父类的发送短信的功能
    public void SendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示");
    }
}

父类-phone

package day07.demo01.demo07;
//继承父类 phone
public class newPhone extends phone {
    //新增来电显示姓名和头像
    //重载phone的电话功能
    @Override
    public void call(){
        //调用父类原始的大电话功能
        super.call();
        //增加自己新的功能——显示姓名和头像
        System.out.println("显示来电姓名");
        System.out.println("显示来电头像");
    }
}

子类-newPhone java基础——day07-1 继承、super、this、抽象类 - 文章图片

package day07.demo01.demo07;

public class demo {
    public static void main(String[] args) {
        //创建一个newphone对象
        newPhone iphone = new newPhone();
        iphone.SendMessage();//子类调用父类发短信功能
        iphone.showNum();//子类调用父类 打电话的功能
        iphone.call();//子类调用重写功能
    }
}

main

　　注意事项：

　　1.子类覆盖父类方法时，必须保证权限小于等于父类权限

　　2.子类覆盖父类方法，返回值类型、函数名和参数列表要一模一样

继承后的特点——构造方法

构造方法的格式和定义：

　　格式：

　　　　public 构造方法名（）{} //无参数的构造方法

　　1.子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用父类构造，后执行子类构造。

　　2.子类构造可以通过super关键字调用父类重载构造（例如一个无参一个有参的构造方法）

　　3.super的父类构造调用，必须是子类构造方法的第一个语句。即一个子类构造不能多次super构造。

父类无参构造：

package day07.demo01.demo08;

public class Fu {
    //定义父类无参构造方法
    public Fu(){
        System.out.println("父类的构造方法");
    }
}

package day07.demo01.demo08;
//继承
public class Zi extends Fu{
    //定义子类无参数构造方法
    public Zi(){
        System.out.println("this is Zi constractor");
    }
}

package day07.demo01.demo08;

public class demo {
    //继承中的构造方法
    public static void main(String[] args) {
        //创建子类对象
        Zi zi = new Zi();
        //发现其先执行了父类的构造方法 再执行子类的构造方法
    }
}

main

父类含参构造：

package day07.demo01.demo08;

public class Fu {
    //定义父类无参构造方法
    public Fu(){
        System.out.println("父类的无参构造方法");
    }
    public Fu(int num){
        System.out.println("父类有参构造方法");
        System.out.println(num);
    }
}

含参-Fu

package day07.demo01.demo08;
//继承
public class Zi extends Fu{
    //定义子类无参数构造方法
    public Zi(){
        super(10); //调用父类有参构造方法
        System.out.println("this is Zi constractor");
    }
}

package day07.demo01.demo08;

public class demo {
    //继承中的构造方法
    public static void main(String[] args) {
        //创建子类对象
        Zi zi = new Zi();
        //发现其先执行了父类的构造方法 再执行子类的构造方法

    }
}

main

super和this

父类空间优先于子类对象的产生

　　在首次创建子类对象时，先初始化父类空间，再创建其子类本身。目的在于子类对象包含了其对应的父类空间，所以先创建父类空间，子类就能获得父类的成员、方法。

　　若父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定会先调用父类的构造方法。（比如说：没有爹哪来的儿子能继承的财产）

super和this的含义

　　super：代表父类的存储空间标识（可以理解为父亲的引用）

　 this：代表当前对象的引用（谁调用代表谁）

super和this的用法

1.访问成员

　　this.成员变量　　//本类的

　　super.成员变量　　//父类的

　　this.成员方法名（）　　//本类的

　　super.成员方法名（）　　//父类的

2.例如

package day07.demo01.demo09;

public class Animal {
    //定义动物类的成员变量
    String name;
    int age;

    //定义动物类的成员方法
    public void eat(){
        System.out.println("Animal:eat");
    }
}

动物类

package day07.demo01.demo09;
//定义猫类 继承父类 Animal
public class Cat extends Animal{
    //eat方法重载

    @Override
    public void eat() {
        //方法重载
        System.out.println("eat fish");
    }

    //定义猫类自己的成员方法
    public void eatTest(){
        super.eat();//---super调用父类的方法
        this.eat();//----this调用本类的方法

    }

}

猫类

package day07.demo01.demo09;

public class demo {
    public static void main(String[] args) {
        //实例化一个Cat对象
        Cat cat = new Cat();
        //继承的成员变量
        cat.name = "小咪";
        cat.age = 2;
        //调用eatTest方法
        cat.eatTest();
    }
}

main

3.访问构造方法

　　this(....)　　----本类的构造方法（具体查看上述手机案例）

　　super(.....) ----父类的构造方法

　　1.子类的每个构造方法中均有默认的super()——调用父类的无参构造。

　　2.手动调用父类构造方法会覆盖默认的super()。

　　3.super()和this()都必须是在构造方法的第一行，所以不能同时出现(例如不能出现两个super这样会报错)。

继承的特点

　　1.一个类只能有一个父类，不可以有多个父类（一个孩子只能有一个爹）

　　class C extends A{} //right

　　class C extends B,C{} //error

　　2.java支持多层次继承（继承体系[孩子只能有一个爹一个爹能有多个孩子]）

　　class Fu{}

　　class A extends Fu{}

　　class B extends Fu{}

　　注：顶级父类是Object类，所有的类默认继承Object,作为父类

　　3.子类和父类是一种相对的概念

内容总结

以上是互联网集市为您收集整理的java基础——day07-1 继承、super、this、抽象类全部内容，希望文章能够帮你解决java基础——day07-1 继承、super、this、抽象类所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/599986.html

来源：【匿名】

【上一篇】Java IO流【下一篇】JAVA/JSP学习系列之五

更多 ►

【java基础——day07-1 继承、super、this、抽象类】教程文章相关的互联网学习教程文章

java基础学习总结(四)——面向对象1【代码】【图】

目录一、面向过程的思想和面向对象的思想二、简单理解面向对象三、面向对象的设计思想四、对象和类的概念五、如何抽象出一个类？六、类（对象）之间的关系七、Java与面向对象八、为什么使用面向对象编程？一、面向过程的思想和面向对象的思想面向对象和面向过程的思想有着本质上的区别, 作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，你应该分析...

Java基础12：JavaDoc生成文档【代码】【图】

Java基础12：JavaDoc生成文档javadoc命令是用来生成自己API文档的参数信息：@author 作者名@version 版本号@since 指明需要最早使用的jdk版本@param 参数名@return 返回值情况@throws 异常抛出情况代码部分：package com.pzz.base;/*** @author PZZ* @version 1.0* @since 1.8*/ public class Doc {String name;/*** @author PZZ* @param name* @return* @throws Exception*/public String test(String name) throws Exception{re...

3、java基础：抽象类与接口的区别【代码】

抽象类我们都知道在面向对象的领域一切都是对象，同时所有的对象都是通过类来描述的，但是并不是所有的类都是来描述对象的。如果一个类没有足够的信息来描述一个具体的对象，而需要其他具体的类来支撑它，那么这样的类我们称它为抽象类。比如new Animal()，我们都知道这个是产生一个动物Animal对象，但是这个Animal具体长成什么样子我们并不知道，它没有一个具体动物的概念，所以他就是一个抽象类，需要一个具体的动物，如狗、猫来...

黑马程序员--Java基础--01基本概念

1.Java的三大技术架构JAVAEE(Java Platform Enterprise Edition): 开发企业环境下的应用程序，主要针对web程序开发；JAVASE(Java Platform Standard Edition): 完成桌面应用程序的开发，是其他两者的基础JAVAME(Java Platform Micro Edition): 开发电子消费产品和嵌入式设备，如手机中的程序我对三大技术构架理解　1.三大技术是指哪三大技术呢？　　　答：三大技术分别指JAVAEE,JAVASE,JAVAME。 2.那么这三种有什么区别呢？　...

Java基础 if if-else if-else if-else 三种示例【代码】

????JDK ：OpenJDK-11?????OS ：CentOS 7.6.1810?????IDE ：Eclipse 2019?03typesetting ：Markdowncodepackage per.jizuiku.base;/*** @author 给最苦* @date 2019/06/29* @blog www.cnblogs.com/jizuiku*/ public class Demo {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubif (true) {System.out.println("第一种格式");}if (false) {System.out.println("???");} else {Syste...

Java基础学习（六）网络编程简介【图】

基础知识：1、osi分层模型和TCP/IP分层模型对应关系 2、七层模型与协议的对应关系网络层 ------------ IP（网络之间的互联协议）传输层 ------------ TCP（传输控制协议）、UDP（用户数据报协议）应用层 ------------ Telnet（Internet远程登录服务的标准协议和主要方式）、FTP（文本传输协议）、HTTP（超文本传送协议）3、IP地址和端口号1、ip地址用于唯一标示网络中的一个通信实体，这个...

每日五题(java基础)

一、HashMap和Hashtable的区别。答： HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。 HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。Hashtable继承自Dictionary类，而H...

【Java基础】11、java方法中只有值传递，没有引用传递【代码】

转自：http://www.cnblogs.com/linkstar/p/5951141.htmlpublic class Example { String testString = new String("good"); char[] testCharArray = {‘a‘,‘b‘,‘c‘}; public static void main(String[] args){ Example ex = new Example(); ex.change(ex.testString,ex.testCharArray); System.out.println(ex.testString); System.out.println(ex.testCharArray); } public void ...

Java基础--Eclipse关联Java源码【图】

打开Eclipse，Window->Preferences->Java 点Edit按钮后弹出：点Source Attachment后弹出：选择Java安装路径下的src.zip文件即可跟Java源码关联原文：https://www.cnblogs.com/daxiang2008/p/9667206.html

java基础69 JavaScript产生伪验证码（网页知识）【代码】【图】

1、伪验证码<!doctype html> //软件版本：DW2018版<html><head><meta charset="utf-8"><title>伪验证码</title></head><script type="text/javascript">function createCode(){var datas = [‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘王‘,‘陈‘,‘晶‘,‘邓‘,‘2‘,‘1‘,‘9‘,‘4‘,‘6‘];var codes ="";for(var i =0;i <4;i++){//随机产生4个索引值var index = Math.floor(Math.random()* datas.length); //0.0-1.0(不包含1.0) ...

java基础——单例设计模式（懒汉式）【代码】

1publicclass Test7 {2// 主函数 3publicstaticvoid main(String[] args) {4 Test7.getInstance().function(9, 81);5 }6 7// 私有成员变量 8private String name;9privateint age; 10privatestatic Test7 test7; 1112private Test7() { 13 } 1415publicstatic Test7 getInstance() { 16if (test7 == null) {// 此行主要为了提高效率17synchronized (Test7.class) { 18if (test7 == null) { 19 t...

黑马程序员————java基础异常处理【代码】

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ------- 1.体系结构 java.lang.Object |----java.lang.Throwable |-------java.lang.Error：错误，java程序对此无能为力，不显式的处理 |-------java.lang.Exception:异常。需要进行处理 |------RuntimeException:运行时异常 |-----ArrayIndexOutOfBoundsException/NullP...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / java基础——day07-1 继承、super、this、抽象类

java基础——day07-1 继承、super、this、抽象类

内容导读

内容图文

java基础——day07-1 继承、super、this、抽象类

继承

概述

例如：生活中的继承

定义

好处

继承的格式

继承后的特点——成员变量

1.成员变量不重名

2.成员变量重名

3.访问private修饰的父类成员变量

继承后的特点——成员方法

1.成员方法不重名

2.成员方法重名——重写（override）

重写的应用（完善父类的缺陷）

继承后的特点——构造方法

构造方法的格式和定义：

super和this

父类空间优先于子类对象的产生

super和this的含义

super和this的用法

1.访问成员

2.例如

3.访问构造方法

继承的特点

内容总结

内容备注

内容手机端

【java基础——day07-1 继承、super、this、抽象类】教程文章相关的互联网学习教程文章

JAVA - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程