java继承原理,java类的继承示例

  java继承原理,java类的继承示例

  00-1010继承介绍,生活中的继承,继承的好处,继承的格式,不能继承的demo子类,不能继承的super和this关键字构造函数,不能用继承方法重写的final-modified类。使用场景和案例介绍@Override重写注释。笔记结束。千千有一大群人。谢谢你给我这个机会。你看这里。希望我的一系列面试问题能对你有所帮助!互相鼓励!

  愿你以后继续爱下去,去山海!

  Java基础知识(继承)

  

目录

 

  00-1010继承是java面向对象编程技术的基石,因为它允许创建层次类。它描述了事物之间的隶属关系,即:是——一种关系。

  继承:子类继承父类的属性和行为,这样子类对象(实例)可以直接拥有与父类相同的属性和行为。子类可以直接访问父类中的非私有属性和行为。

  

继承

 

  兔子和长颈鹿属于食草动物,老虎和狮子属于食肉动物。食草动物和食肉动物都属于动物。

  兔子、长颈鹿、老虎和狮子都是动物吗?答案是肯定的!虽然食草动物和食肉动物都属于动物,但它们的性质和行为是不同的,所以子类会有其父代的一般特征和自身的特征。当多个类中存在相同的属性和行为时,我们可以将这些内容提取到单个类中。然后,多个类不再需要定义这些属性和行为,只需要继承那个类。

  00-1010提高代码复用性(减少代码冗余,复用相同代码)。使阶级之间的关系。子类拥有父类的非私有属性和方法。子类可以有自己的属性和方法,也就是说,它可以扩展父类。子类可以用自己的方式实现父类的方法。提高了类之间的耦合度(继承的缺点,耦合度越高,代码之间的联系越紧密,代码的独立性越差)。Java的继承是单一继承,但也可以是多重继承。单一继承意味着一个子类只能继承一个父类。多重继承是指,比如B类继承A类,C类继承B类,所以根据关系,B类是C类的父类,A类是B类的父类,这是Java继承区别于C类的一个特征。

  00-1010在Java中,可以通过extends关键字声明一个类是从另一个类继承而来的。一般形式如下:

  父类{}子类扩展父类{ }

  有一点需要注意:Java不支持多重继承,但它支持。如下所示:

  A类{ }类扩展A {(右)}

  类扩展了a,b {(错误)}

  类扩展b {(右)}

  顶级类是对象类。默认情况下,的所有类都继承Object作为父类。

  00-1010写父类对应的子类信息。

  其结构如下:

  代码如下:

  父人员:

  包com . NZ . POJO;公共类Person {私有字符串名称;私人年龄;公共字符串getName(){ return name;} public void set name(String name){ this . name=name;} public int getAge(){ return age;} public void setAge(int age){ this . age=age;}}子类Student没有附加的属性和方法:

  包com . NZ . POJO;/* * *继承了Person的唯一名字,年龄,*没有额外的唯一属性和方法*/Teacher,Public Class Student Extensions Person { }的子类,有一个额外的属性薪水和唯一的教学方法:

  包com . NZ . POJO;/* * *继承了人特有的姓名、年龄,*添加了自己特有的薪资属性和独特的授课方式*/pu

  blic class Teacher extends Person{ // 工资 private double salary ; // 特有方法 public void teach(){ System.out.println("老师在认真教书!"); } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; }}pre>编写测试代码:

  

package com.nz;import com.nz.pojo.Student;import com.nz.pojo.Teacher;public class InheritDemo { public static void main(String[] args) { Teacher teacher = new Teacher(); teacher.setName("最爱吃鱼罐头"); teacher.setAge(18); teacher.setSalary(1999.99); System.out.println(teacher.getName()); System.out.println(teacher.getAge()); System.out.println(teacher.getSalary()); teacher.teach(); Student student = new Student(); student.setName("罐头"); student.setAge(12); //student.setSalary(1999.99); // student没有工资属性,报错! System.out.println(student.getName()); System.out.println(student.getAge()); }}

结果如下:

 

  

最爱吃鱼罐头181999.99老师在认真教书!罐头12

 

  

从结果来看,子类继承父类,就可以直接得到父类的成员变量和方法。而子类可以编写一些特有的属性和方法,但是是否可以继承所有成分呢?

 

  

 

  

子类不能继承的内容

并不是父类的所有内容都可以给子类继承的:

 

  

 

  

super 与 this 关键字

这里先将这两个关键字,super和this在继承关系中,运用比较频繁。

 

  super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。this关键字:指向自己本类的引用。super和this完整的用法如下:

  

this.成员变量 -- 本类的super.成员变量 -- 父类的

 

  this.成员方法名() -- 本类的super.成员方法名() -- 父类的

  

具体演示,创建测试InheritDemo2:

package com.nz;public class InheritDemo2 { public static void main(String[] args) { Animal a = new Animal(); a.eat(); Cat cat = new Cat(); cat.eatFish(); }}class Animal { void eat() { System.out.println("animal : eat"); }}class Cat extends Animal { void eat() { System.out.println("cat : eat"); } void eatFish() { this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 }}

调用结果如下:

 

  

animal : eatcat : eatanimal : eat

 

  

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

 

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

  

 

  

构造器不能被继承

子类不能继承父类的构造器(构造方法或者构造函数),它只是调用(隐式或显式)。因为子类有自己的构造器。值得注意的是子类可以继承父类的私有成员(成员变量,方法),只是子类无法直接访问而已,可以通过getter/setter方法访问父类的private成员变量。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过super 关键字调用父类的构造器并配以适当的参数列表。如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。演示过程:

package com.nz;public class InheritDemo3 { public static void main(String[] args) { System.out.println("------Teacher 类继承------"); Teacher teacher = new Teacher(); Teacher teacher2 = new Teacher("张三"); System.out.println("------Student 类继承------"); Student student = new Student(); Student student2 = new Student("张三三"); }}// 父类class Person { private String name; Person(){ System.out.println("调用了父类的无参构造器: Person()"); } Person(String name) { System.out.println("调用了父类的带参构造器: Person(String name)"); this.name = name; }}// Teacher子类继承Personclass Teacher extends Person{ private String name; Teacher(){ // 自动调用父类的无参数构造器 因为会有默认super(); System.out.println("Teacher"); } public Teacher(String name){ super("最爱吃鱼罐头"); // 调用父类中带有参数的构造器 System.out.println("Teacher(String name):"+name); this.name = name; }}// Student子类继承Personclass Student extends Person{ private String name; Student(){ super("heihei"); // 调用父类中带有参数的构造器 System.out.println("SubClass2"); } public Student(String name){ // 自动调用父类的无参数构造器 System.out.println("Student(String name):"+name); this.name = name; }}

结果如下:

 

  

------Teacher 类继承------调用了父类的无参构造器: Person()Teacher调用了父类的带参构造器: Person(String name)Teacher(String name):张三------Student 类继承------调用了父类的带参构造器: Person(String name)SubClass2调用了父类的无参构造器: Person()Student(String name):张三三

 

  

 

  

final修饰的类不能被继承

final 关键字主要用在三个地方:变量、方法、类。

 

  修饰类:表示该类不能被继承;修饰方法:表示方法不能被重写;修饰变量:表示变量只能一次赋值以后值不能被修改(常量)。final 的特点:

  对于一个 final 变量,如果是基本数据类型的变量,则其数值一旦在初始 化之后便不能更改;如果是引用类型的变量,则在对其初始化之后便不 能再让其指向另一个对象。当用 final 修饰一个类时,表明这个类不能被继承。final 类中的所有成员 方法都会被隐式地指定为 final 方法。使用 final 方法的原因有两个。第一个原因是把方法锁定,以防任何继承 类修改它的含义;第二个原因是效率。在早期的 Java 实现版本中,会将 final 方法转为内嵌调用。但是如果方法过于庞大,可能看不到内嵌调用 带来的任何性能提升(现在的 Java 版本已经不需要使用 final方法进行这些优化了)。类中所有的 private 方法都隐式地指定为 final。我们测试下修饰类后到底能不能继承:

  

package com.nz;public class InheritDemo4 {}// 父类final class Fu { private String name;}//class Zi extends Fu{ // Cannot inherit from final com.nz.Fu 会显示没办法继承Fu//}

结果:可以看出来在被final修饰的Fu类没办法继承,而且在编译期间就会报错了,没办法通过运行。

 

  

 

  

方法重写

 

  

介绍

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

 

  

 

  

使用场景与案例

发生在子父类之间的关系。 子类继承了父类的方法,但是子类觉得父类的这方法不足以满足自己的需求,子类重新写了一个与父类同名的方法,以便覆盖父类的该方法。

 

  写个测试案例:

  

package com.nz;public class InheritDemo5 { public static void main(String[] args) { // 创建子类对象 Cat lanMao = new Cat(); // 调用父类继承而来的方法 lanMao.run(); // 调用子类重写的方法 lanMao.sing(); }}class Animal{ public void sing(){ System.out.println("动物都可以唱歌!"); } public void run(){ System.out.println("动物都可以跑!"); }}class Cat extends Animal { public void sing(){ System.out.println("我们一起学猫叫,一起喵喵喵!让我们一起撒个娇"); }}

运行结果:

 

  

动物都可以跑!我们一起学猫叫,一起喵喵喵!让我们一起撒个娇

 

  

可以看出,蓝猫调用了重写后的sing方法。

 

  

 

  

@Override重写注解

@Override:注解,重写注解校验!这个注解标记的方法,就说明这个方法必须是重写父类的方法,否则编译阶段报错。建议重写都加上这个注解,一方面可以提高代码的可读性,一方面可以防止重写出错!加上后的子类代码形式如下:

 

  

class Cat extends Animal { // 声明不变,重新实现 // 方法名称与父类全部一样,只是方法体中的功能重写了! @Override public void sing(){ System.out.println("我们一起学猫叫,一起喵喵喵!让我们一起撒个娇"); }}

 

  

注意事项

方法重写是发生在子父类之间的关系。子类方法覆盖父类方法,必须要保证权限大于等于父类权限。子类方法覆盖父类方法,返回值类型、函数名和参数列表都要一模一样。、

 

  

完结

相信各位看官看到这里,都对Java继承有了一定的了解吧,继承在Java的特性里还是占据比较大得多作用,他还有很多特点:

 

  高代码的复用性(减少代码冗余,相同代码重复利用)。使类与类之间产生了关系。子类拥有父类非 private 的属性、方法。子类可以拥有自己的属性和方法,即子类可以对父类进行扩展,可以用自己的方式实现父类的方法。提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。让我们也一起加油吧!本人不才,如有什么缺漏、错误的地方,也欢迎各位人才大佬评论中批评指正!

  学到这里,今天的世界打烊了,晚安!虽然这篇文章完结了,但是我还在,永不完结。我会努力保持写文章。来日方长,何惧车遥马慢!

  感谢各位看到这里!愿你韶华不负,青春无悔!

  

 

  到此这篇关于Java由浅入深刨析继承的文章就介绍到这了,更多相关Java 继承内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT!

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: