java 继承 学习笔记

最新推荐文章于 2022-03-13 10:37:23 发布
最新推荐文章于 2022-03-13 10:37:23 发布
阅读量196 收藏
点赞数 2
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaologos/article/details/96310667
版权

继承

一、面向对象继承性

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(14);
        stu.setName("孙笑川");
        stu.tell();
    }
}
class Person{
    private String name;
    private int age;

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

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

    public void tell(){
        System.out.println("姓名： "+this.name+"、 年龄： "+this.age);
    }
}

class Student extends Person{
}

1. 在子类中扩展方法

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setSchool("平津军官学校");
        stu.setAge(14);
        stu.setName("孙笑川");
        
        stu.tell();
        stu.getSchool();
    }
}
class Person{
    private String name;
    private int age;

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

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

    public void tell(){
        System.out.println("姓名： "+this.name+"、 年龄： "+this.age);
    }
}

class Student extends Person{
    private String school;// 扩充方法
    public void setSchool(String s){
        this.school = s;
    }
    public void getSchool(){
        System.out.println("school is "+ this.school);
    }
}

2. 子类对象实例化对象

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student("孙笑川", 14, "平津大学");
        stu.tell();
        stu.getSchool();
    }
}
class Person{
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

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

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

    public void tell(){
        System.out.println("姓名： "+this.name+"、 年龄： "+this.age);
    }
}

class Student extends Person{
    private String school;
    public Student(String name, int age, String school){
        super(name, age); // 调用父类构造方法
        this.school = school;
    }

    public void getSchool(){
        System.out.println("school is "+ this.school);
    }
}

3. 继承限制

1. 单继承

多层继承：继承层次不要过多

2. 非私有操作

不允许直接访问非私有操作

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student("孙笑川");
        System.out.println(stu.getInfo());
    }
}
class Person{
    private String name;

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

    public String getName(){
        return this.name;
    }
}

class Student extends Person{
    private String school;
    public Student(String name){
        setName(name);
    }

    public String getInfo(){
        return "姓名： "+ getName();
    }
}

本程序中Person父类定义的name属性虽然可以被子类继承使用，但是由于private定义，所以在子类中无法直接访问私有属性访问，只能通过getter方法访问，所以该属性属于隐式继承

二、覆写

子类可能会和父类定义名称相同的方法和属性，此时情况被称为覆写

1. 覆写定义

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student("孙笑川");
        System.out.println(stu.getInfo());
        Person per = new Person();
        per.printInfo();
        stu.printInfo();
    }
}
class Person{
    private String name;

    public void setName(String name){
        this.name = name;
    }
    public void printInfo(){//父类方法
        System.out.println("笑川桑，你还在吗？");
    }
    public String getName(){
        return this.name;
    }
}

class Student extends Person{
    private String school;
    public Student(String name){
        setName(name);
    }
    public void printInfo(){// 覆写方法
        System.out.println("平津原来是没有雪的");
    }

    public String getInfo(){
        return "姓名： "+ getName();
    }
}

使用super调用父类未覆写方法，使用this调用子类覆写方法

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student("孙笑川");
        stu.getInfo();
    }
}
class Person{
    private String name;

    public void setName(String name){
        this.name = name;
    }
    public String printInfo(){
        return "笑川桑，你还在吗？";
    }
    public String getName(){
        return this.name;
    }
}

class Student extends Person{
    private String school;
    public Student(String name){
        setName(name);
    }
    public String printInfo(){
        return "平津原来是没有雪的";
    }

    public void getInfo(){
        System.out.println("姓名： "+ getName());
        System.out.println("父类方法： "+ super.printInfo());// 为覆写的父类方法
        System.out.println("子类方法： " + this.printInfo());// 为子类已经覆写的方法
    }
}

2. 方法覆写限制

核心问题：被子类所覆写的方法不能拥有比父类更严格的访问控制权限，也就是父类方法是public，子类覆写方法不能是default

No.区别重载覆写
1英文OverloadingOverriding
2定义方法名称相同，参数的类型和个数不同，返回值按标准要一致，也可以不一致，会强制进行转换方法名称、参数的类型及个数、返回值类型完全相同
3权限没有权限要求被子类覆写的方法的访问控制权限不能比父类方法更严格
4范围发生在一个类中发生在继承关系类中

3. 属性覆盖

子类除了可以对父类进行覆写外，也可以对非private定义的父类属性进行覆盖，至于要定义相同的名称就行

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.getInfo();
    }
}
class Person {
    String info = "23124"; // 父类属性
}
class Student extends Person{
    int info = 123;// 子类覆写属性
    public void getInfo(){
        System.out.println("child info is "+this.info+ "、parent info is "+ super.info);
    }
}

三、final 关键字

实现以下功能：

  1. 定义不能够被继承的类

final class Channel{}该类不能被继承

  1. 定义不能够覆写的方法
public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.getInfo();
    }
}
class Person {
    public final void getInfo(){// 无法被覆写
        System.out.println("父类方法");
    }
}
class Student extends Person{
    public void getInfo(){// IDE 中会报错
        System.out.println("child info is "+this.info+ "、parent info is "+ super.info);
    }
}
  1. 定义常量（全局常量）

final int ON = 1

定义全局常量，无法被更改

四、Annotation 注解

1. 准确覆写 Override

用在子类覆写父类方法使用了Override注解，就可以直接分别出哪些是覆写方法，哪些是子类扩充方法。同时利用@Override 注解也可以在编译时检测出因为子类拼写错误所造的方法覆写错误

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.getInfo();
    }
}
class Person {
    String info = "23124";
    public void getInfo(){
        System.out.println("父类方法");
    }
}
class Student extends Person{
    int info = 123;
    // 注释
    @Override
    public void getInfo(){
        System.out.println("child info is "+this.info+ "、parent info is "+ super.info);
    }
}
2. 过期声明

程序开发是迭代进行的，因此有些不推荐使用的结构，所以就有针对此的注释 @Deprecated

public class ObjectDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.getInfo();
        stu.getInfo1();// 函数名称上会出现删除线
    }
}
class Person {
    String info = "23124";
    public void getInfo(){
        System.out.println("父类方法");
    }
    @Deprecated
    public void getInfo1(){
        System.out.println("aenfasef");
    }
}
class Student extends Person{
    int info = 123;
    @Override
    public void getInfo(){
        System.out.println("child info is "+this.info+ "、parent info is "+ super.info);
    }
}
3. 压制警告

@SuppressWarning(value = {“deprecation”})：可以去除使用@Deprecated注释的函数体发生的Warning

五、面向对象多态性

展现形式1：

  1. 方法重载
  2. 方法覆写

展现形式2：

1. 对象向上转型

父类 父类实例 = 子类实例，自动完成转换

public class ObjectDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.tell();
        Person person1 = new Student();// 向上转型
        person1.tell();
        Person person2 = new Worker();
        person2.tell();
    }
}
class Person {
    public void tell(){
        System.out.println("人来了！");
    }
}
class Student extends Person{
    public void tell(){
        System.out.println("学生来了！");
    }
}
class Worker extends Person{
    public void tell(){
        System.out.println("工人来了！");
    }
}

统一方法参数

public class ObjectDemo {
    public static void main(String[] args) {
        Home.tell(new Student()); //不同的实例化对象，但都是一个Person类型
        Home.tell(new Worker());
    }
}
class Person {
    public void tell(){
        System.out.println("人来了！");
    }
}
class Student extends Person{
    public void tell(){
        System.out.println("学生来了！");
    }
}
class Worker extends Person{
    public void tell(){
        System.out.println("工人来了！");
    }
}
class Home{
    public static void tell(Person per){
        per.tell();
    }
}
2. 对象向下转型

子类 子类实例 = （子类）父类实例，强制完成转换

public class ObjectDemo {
    public static void main(String[] args) {
        Person per = new Superman(); //先向上转型
        per.run();
        Superman sup = (Superman) per;// 再向下强制转型
        sup.fly();
    }
}
class Person {
    public void run(){
        System.out.println("跑步！");
    }
}
class Superman extends Person{
    public void fly(){
        System.out.println("我会飞翔！");
    }
}
4. instanceof 关键字

对象的向下转型有安全隐含，为了保证安全性，可以在转换前通过instanceof队对象所属类型进行判断，语法如下

对象 instanceof 类

返回一个boolean类型的数据

public class ObjectDemo {
    public static void main(String[] args) {
        Person per1 = new Person();
        Person per2 = new Superman();

        System.out.println(per1 instanceof Person);
        System.out.println(per1 instanceof Superman); //判断对象所属类型false，未建立联系
        System.out.println(per2 instanceof Person);
        System.out.println(per2 instanceof Superman);
        per2.run();
        Superman spm1 = (Superman) per1;// 发生ClassCastException
        spm1.fly();
        Superman spm2 = (Superman) per2; //向下转型
        spm2.fly();
    }
}
class Person {
    public void run(){
        System.out.println("跑步！");
    }
}
class Superman extends Person{
    public void fly(){
        System.out.println("我会飞翔！");
    }
}

进行安全的向下转型

public class ObjectDemo {
    public static void main(String[] args) {
        Person per = new Superman();
        if (per instanceof Superman){ // 先判断对象所属类型，再向下转型
            Superman spm = (Superman) per;
            spm.fly();
        } else {
            System.out.println("错误");
        }
    }
}
class Person {
    public void run(){
        System.out.println("跑步！");
    }
}
class Superman extends Person{
    public void fly(){
        System.out.println("我会飞翔！");
    }
}

六、Object类

Object是所有类的父类，所有利用class关键字定义的类全部默认继承自Object类

class Person{}和class Person extends Object{}是相同的

public class ObjectDemo {
    public static void main(String[] args) {
        Object per = new Superman();// 可以直接向上转型到爷爷类
        if (per instanceof Superman){
            Superman spm = (Superman) per;// 向下转型到孙子类
            spm.fly();
        } else {
            System.out.println("错误");
        }
    }
}
class Person {
    public void run(){
        System.out.println("跑步！");
    }
}
class Superman extends Person{
    public void fly(){
        System.out.println("我会飞翔！");
    }
}

Object可以接受所有的引用数据类型

1. 获取对象信息

Object提供了toString方法，打印对象信息

public class ObjectDemo {
    public static void main(String[] args) {
        Person per = new Person("孙笑川", 18);
        System.out.println(per.toString());
    }
}
class Person {
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString(){
        return "姓名：" + this.name + "、年龄：" + this.age;
    }
}

Object.toString方法的默认实现

public String toString(){
        return getClass().getName()+"@"+Integer.toHexString(hashCode());
}
2. 对象比较

Object类中的equals方法是基于对象是否相同来建立的，主要是判断两个对象的地址是否相同，”对象.equals(对象)“ 效果等同“对象 == 对象“

String类中覆写了equals方法public boolean equals(Object obj)

覆写equals方法

public class ObjectDemo{
    public static void main(String[] args) {
        Person per1 = new Person("孙笑川",18);
        Person per2 = new Person("孙笑川",18);
        System.out.println(per1.equals(per2));
    }
}
class Person extends Object{
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    // 覆写的目的是为了判断new的两个对象是否创建的是同一人
    public boolean equals(Object obj){
        if (!(obj instanceof Person)){//判断是否为Person类
            return false;
        }
        if (obj == null){// 判断目标是否为空
            return false;
        }
        if (this == obj){// 判断地址是否相同，地址相同则认为是同一个对象
            return true;
        }
        Person per = (Person) obj;
        return this.name.equals(per.name) && this.age == per.age;// 然后判断对象的属性是否相同
    }
}
yaologos
关注
专栏目录
java继承笔记
TianMing013的博客
07-12 139
1.什么是类?什么是对象? 1)现实生活是由很多对象组成的 2)对象:软件中真实存在的单个个体/东西
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
Java 继承学习笔记
徘徊在牛A与牛C之间的码农
01-22 192
继承笔记： 1.关键词：extends public class Zi extends Fu ( 子父类的有关系，is a A是B的一种) -------------------------------------------------------------- 2. super this 访问子父类的有关系 ： 生成的子类对象，访问变量是的先后关系：局部变量－》...
JAVA中继承的学习笔记
mxlmhgzw的专栏
10-08 818
面向对象编程有三个特征，即封装、继承和多态。 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？ 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++
JAVA继承个人学习笔记
seeflyliu的博客
11-17 387
我觉得继承就一个类的扩展，被扩展的类就是父类，扩展得到的类就是子类。在子类中可以添加新的数据域或者方法来更加具象化的描述一个对象。 它们的共同点与区别： 数据域：父类中声明的非私有数据域都可以当做是在子类中声明的数据域一样来使用。而私有数据域则需要通过访问器或者修改器访问。 构造方法：父类中的构造方法在子类中可以通过SUPER关键字来访问。 方法：和数据域一样，唯一的区别就是父类中定义的私
JAVA学习笔记之继承
想去海邊
11-01 691
继承是两个
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java学习笔记(必看经典).pdf
最新发布
10-20
2. 继承：一个类可以继承另一个类的属性和方法，减少了代码的重复，增强了代码的复用性。 3. 多态：同一种行为在不同对象上有不同的表现形式，提供了灵活的扩展能力。 Java中定义类的语法是`class ClassName { ... ...
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性...通过深入学习和实践，你可以不断提升自己的Java编程能力。
java学习笔记
12-22
Java学习笔记涵盖了大量的Java基础知识，包括面向对象编程和高级特性。以下是对这些知识点的详细解释： **基础语法** 1. **数据类型**：Java有基本数据类型和引用数据类型。基本数据类型包括整型（byte, short, int...
Java继承笔记
m0_51664084的博客
02-14 507
Java继承笔记，Java入门，Java相关内容，面向对象三大特征，Java初级 ​​ 目录 1.概述 2.格式 3.继承中子类的特点 4.继承的好处和弊端 5.什么时候使用继承 6.继承中变量的访问特点 7.super关键字 8.继承中构造方法的访问特点 9.继承中成员方法的访问特点 .方法重写 11.方法重写注意事项 12.Java中继承的注意事项 1.概述 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。
Java 继承笔记
Little_progra的博客
01-26 230
关于java语言当中的继承: 1、继承是面向对象三大特征之一,三大特征分别是:封装、继承、多态 2、继承"基本"的作用是:代码复用。但是继承最v重要"的作用是:有了继承才有了以后 方法的覆盖"和"多态机制""。 3、继承语法格式: [修饰符列表] class 类名 extends 父类名{ 类体=属性+方法 } 4、java语言当中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。在C++中支持多继承。 5、关于继承中的一些术语: B类继承A类,...
继承笔记
yehaotianyhy的博客
03-06 169
1.继承关键字——extendspublic class Dog extens Pet{}2.继承中私有的成员无法继承,构造函数也无法继承,无法重写。3.不可以使用public或protected修饰类。4.super-对当前对象的直接父类对象的默认引用public Dog(String name,String strain) {super(name);this.strain = strain;}...
JAVA学习笔记----继承
jiangzihao110120的博客
03-31 210
继承继承是一种子父类关系，其中 子类继承了父类一般属性和方法。如动物类：      子类：食草                 食肉           子类：羚羊，奶牛        豹子，狮子。注意：      1.extends 关键字，------继承        语法：public class 子类 extends 父类2. 父类的私有化属性和方法不能被子类继承（访问？？）继承的好处1...
Java学习笔记——继承
weixin_45875493的博客
03-13 572
继承一、概述二、好处三、继承的格式四、继承后的特点——成员变量五、继承后的特点——成员方法六、继承后的特点——构造方法 一、概述 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 例如：儿子继承了父亲的财产，儿子不需要努力就有钱了。 二、好处 1、提高代码的复用性 2、类与类之间产生了关系，是多态的提前 三、继承的格式 通过extends关键字，可以声明一个类继承另外一个父类，定义格式如下： class 父类{ ..... }
java学习笔记-继承
小王的博客
02-07 326
1、继承 格式：public class 子类名 extends 父类名{} 子类继承特点：子类可以有父类的内容，还可以有自己特有的内容 好处：提高代码的复用性（多个类相同的成员可以放到同一个类中） 提高了代码的维护性（如果方法的代码需要修改，修改一处即可） 弊端：削弱了子类的独立性 什么时候使用继承？如果a是b的一种，就说明存在继承关系，可以考虑使用继承，否则不能滥用继承；如苹果是水果的一种 2、super 可以访问父类的成员变量 与this关键字的用法相似（访问成员变量、构造方法、成员方法） 3、继承中
java学习day8-继承的理解，重载，重写区别
a5421901的专栏
04-20 182
1.继承的定义把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，2.继承的格式：class 子类名 extends 父类名 {}3.继承的优点A:提高了代码的复用性B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提4.继承的缺点A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。   原则：低耦合，高内聚。   耦合：类与类的...
Java学习笔记：面向对象、继承与多态
"Java学习笔记包含了面向对象编程的多个核心概念，如继承、方法重写、属性覆盖、super关键字的使用、final关键字的作用、抽象类的定义与使用、接口的实现以及对象的多态性。" Java学习笔记深入探讨了面向对象编程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值