Java继承超详细教程

 更新时间:2023年11月20日 11:04:40   作者:白巧克力LIN  
继承是面向对象语法的三大特征之一,继承可以降低代码编写的冗余度,提高编程的效率,通过继承,子类获得了父类的成员变量和方法,一个子类如何继承父类的字段和方法,如何修改从父类继承过来的子类的方法呢,今天我们开始学习有关Java继承的知识,感兴趣的朋友一起看看吧

前言

继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度,提高编程的效率。通过继承,子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法,如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关Java继承的知识。

继承

继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

继承的作用:通过继承可以快速创建新的类,实现代码的重用,提高程序的可维护性,节省大量创建新类的时间,提高开发效率和开发质量。

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

class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

例如:

class teacher{             //声明一个teacher类为父类
	String name;      	   //定义父类的成员变量name、age   
	int age;
	void show(){           //定义父类成员方法,将成员变量输出
		System.out.println(name); 	  
		System.out.println(age); 
	}
}
class Student extends teacher {     //声明一个Student类为子类并继承父类
}
public class myfirst {
	public static void main(String[] args) {
	System.out.println("学生");
	Student student=new Student();     //声明一个Student类的实例对象student
	student.name="Tom";                //子类调用父类的成员变量name并赋值
	student.age=19;                    //子类调用父类的成员变量age并赋值
	student.show();                    //子类调用父类的成员方法show
	}
}

运行结果为:

学生
Tom
19

注意:

  • 子类不能选择性继承父类;
  • Java不支持多重继承,但一个类可以实现多个接口,从而克服单继承的缺点;
  • 构造方法不会被子类继承,但可以从子类中调用父类的构造方法。

继承的优点

  • 继承过来的字段和方法,可以像任何其他字段和方法一样被直接使用;
  • 在子类中可以声明一个与父类中同名的新字段或静态方法,从而“隐藏”父类中的字段或方法;
  • 可以在子类中声明一个在父类中没有的新字段和方法;
  • 可以在子类中编写一个父类当中具有相同名的新实例方法,这称为“方法重写”或“方法覆盖”;
  • 可以在子类中编写一个调用父类构造方法的子类构造方法,既可以隐式地实现,也可以通过使用关键字super来实现。

重写和隐藏父类方法

子类继承了父类中的所有成员及方法,但在某种情况下,子类中该方法所表示的行为与其父类中该方法所表示的行为不完全相同,例如,在父类语言中定义了说话这个方法,而在子类中说话的方法是不同的:外国人说英文,中国人说中文,这时我们就需要重写或隐藏父类的该方法。

重写父类中的方法

当一个子类中一个实例方法具有与其父类中的一个实例方法相同的签名(指名称、参数个数和类型)和返回值时,称子类中的方法“重写”了父类的方法。例如:

class A{
	public void sayHello() {                      //输出英文欢迎
		System.out.println("Hello,Welcome to Java!!!");
	}
	public void sayBye() {
		System.out.println("GoodBye,everyone");
	}
}
class B extends A {           
    public void sayHello() {                      //输出中文欢迎  
    	System.out.println("大家好,欢迎学习Java!!!");
    }
}
public class myfirst {
	public static void main(String[] args) {
	B b=new B();                                //创建子类B的一个实例对象,使用默认构造方法
	b.sayHello();                               //调用子类中重写的方法
	b.sayBye();                                 //调用父类中的方法
	}
}

运行结果为:

大家好,欢迎学习Java!!!
GoodBye,everyone

注意:重写的方法具有与其所重写的方法相同的名称、参数数量、类型和返回值。

隐藏父类中的方法

如果一个子类定义了一个静态类方法,而这个类方法与其父类的一个类方法具有相同的签名(指名称、参数格式和类型)和返回值,则称在子类中的这个类方法“隐藏”了父类中的该类方法。

  • 当调用被重写的方法时,调用的版本是子类的方法;
  • 当调用被隐藏的方法时,调用的版本取决于是从父类中调用还是从子类中调用。
class A{
	public static void sayHello() {             //静态类方法
		System.out.println("大家好,这是A的静态类方法");
	}
	public void sayHello2() {                   //实例方法
		System.out.println("大家好,这是A中的实例方法");
	}
}
class B extends A {    
    public static void sayHello() {             //静态类方法
    	System.out.println("大家好,这是B的静态类方法");
    }
    public void sayHello2() {                   //实例方法
    	System.out.println("大家好,这是B的实例方法");
    }
}
public class myfirst {
	public static void main(String[] args) {
	    B b=new B();                           //创建B类的实例对象b
	    A a=b;                                 //隐式对象类型转换
	    A.sayHello();                          //调用A类的静态类方法
	    a.sayHello();                          //调用a对象的静态类方法
	    B.sayHello();                          //调用B类的静态方法
	    a.sayHello2();                         //调用a对象的实例方法
	    b.sayHello2();                         //调用b对象的的实例方法
	    A a2=new A();                          //创建A类的实例对象a2
	    a2.sayHello2();                        //调用a2对象的实现方法
	}
}

运行结果为:

大家好,这是A的静态类方法
大家好,这是A的静态类方法
大家好,这是B的静态类方法
大家好,这是B的实例方法
大家好,这是B的实例方法
大家好,这是A中的实例方法

可以看出,得到调用的隐藏方法是父类中的方法,而得到调用的重写方法是子类中的方法。

方法重写和隐藏后的修饰符

在子类中被重写的方法,其访问权限允许大于但不允许小于被其重写的方法,例如:父类中一个受保护的实例方法(protected)在子类中可以是公共的(public)的,但不可以是私有的(private)。如果一个方法在父类中是static方法,那么在子类也必须是static方法;如果一个方法在父类中是实例方法,那么在子类中也必须是实例方法。

子类访问父类私有成员

子类继承其父类的所有public和protected成员,但不能继承其父类的private成员。那么如何在子类中访问到父类中的字段呢,我们可以在父类中提供用来访问其私有字段的public或protected方法,子类使用这些方法来访问相应的字段。例如:

class A{                     //父类A
	private int value=10;    //声明一个私有变量value并赋值为10
	public int getvalue() {  //声明一个公有成员方法getvalue,返回value
		return value;
	}
}
class B extends A{           //A的子类B
}
public class myfirst {    
	public static void main(String[] args) {
	  B b=new B();           //创建子类B的一个实例对象
	  System.out.println("子类通过父类提供的公共接口访问A中的私有字段value:"+b.getvalue());
	}
}

运行结果为:

子类通过父类提供的公共接口访问A中的私有字段value:10

使用super关键字

使用super调用父类中重写的方法、访问父类中被隐藏的字段

子类重写了父类中的某一个方法,隐藏父类中的字段,假如想在子类中访问到父类中被重写的方法和隐藏父类的字段,可以在子类中通过使用关键字super来调用父类中被重写的方法和访问父类中被隐藏的字段。例如:

package first;
class A{
    public String name="张飞";         //添加成员变量
	public void say() {                //添加成员方法say
		System.out.println("我是父类A成员方法say");
	}
}
class B extends A{
    public String name="关羽";         //与父类中同名的字段,隐藏父类
	public void say(){                 //重写方法say
		super.say();                   //使用super关键字调用父类中的方法
		System.out.println("我是子类B成员方法say");
        System.out.println("父类的name名字:"+super.name); //使用super关键字访问父类中的变量
	}
}
public class myfirst {
	public static void main(String[] args) {
	  B b=new B();                     //创建子类的一个实例对象
	  b.say();                         //调用子类中重写的方法
	  System.out.println("子类的name名字:"+b.name);   //调用子类中的name
	}
}

运行结果为:

我是父类A成员方法say
我是子类B成员方法say
父类的name名字:张飞
子类的name名字:关羽

使用super调用父类的无参数构造方法/有参数构造方法

子类不继承其父类的构造方法。

  • 当使用无参数的super()时,父类的无参数构造方法就会被调用;
  • 当使用带有参数的super()方法时,父类的有参数构造方法就会被调用。

例如:

class SuperClass {              //创建父类SuperClass
	  private int n;            //声明一个私有变量n
	  SuperClass(){             //父类无参数构造方法
	    System.out.println("这是父类SuperClass无参数构造方法");
	  }
	  SuperClass(int n) {       //父类有参数构造方法
	    System.out.println("这是父类SuperClass有参数构造方法");
	    this.n = n;
	  }
	}
	class SubClass extends SuperClass{     // SubClass类继承SuperClass类
	  private int n;                       //声明一个私有变量n
	  SubClass(){                          // 自动调用父类的无参数构造器
	    System.out.println("这是子类无参数构造方法");
	  }  
	  public SubClass(int n){              //子类有参数构造方法
	    super(300);                        //调用父类中带有参数的构造器
	    System.out.println("这是子类有参数构造方法"+n);
	    this.n = n;
	  }
	}
public class myfirst {
	public static void main(String[] args) {
		    SubClass sc1 = new SubClass();      //创建子类SubClass实例对象,调用其无参数构造方法
		    SubClass sc2 = new SubClass(100);   //创建子类SubClass实例对象,调用其有参数构造方法
	}
}

运行结果为:

这是父类SuperClass无参数构造方法
这是子类无参数构造方法
这是父类SuperClass有参数构造方法
这是子类有参数构造方法100

注意

  • 如果要初始化父类中的字段,可以在子类的构造方法中通过关键字super调用父类的构造方法;
  • 对父类的构造放的调用必须放在子类构造方法的第一行;
  • 如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器;
  • 如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表;
  • 子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。

到此这篇关于Java继承超详细的文章就介绍到这了,更多相关Java继承内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • SpringBoot项目打包war包时无法运行问题的解决方式

    SpringBoot项目打包war包时无法运行问题的解决方式

    在开发工程中,使用启动类启动能够正常启动并测试,下面这篇文章主要给大家介绍了关于SpringBoot项目打包war包时无法运行问题的解决方式,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2022-06-06
  • Java工厂模式定义与用法实例分析

    Java工厂模式定义与用法实例分析

    这篇文章主要介绍了Java工厂模式定义与用法,结合具体实例形式分析了java工厂模式定义、使用相关操作技巧,并总结了类图原理,需要的朋友可以参考下
    2019-07-07
  • SpringBoot 使用 Sa-Token 完成注解鉴权功能(权限校验)

    SpringBoot 使用 Sa-Token 完成注解鉴权功能(权限校验)

    Sa-Token 是一个轻量级 java 权限认证框架,主要解决登录认证、权限认证、单点登录、OAuth2、微服务网关鉴权 等一系列权限相关问题,这篇文章主要介绍了SpringBoot使用Sa-Token完成注解鉴权功能,需要的朋友可以参考下
    2023-05-05
  • 关于springboot中的SPI机制

    关于springboot中的SPI机制

    这篇文章主要介绍了springboot中的SPI机制,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-01-01
  • Maven报错之导入Junit包来实现@Test注解问题

    Maven报错之导入Junit包来实现@Test注解问题

    这篇文章主要介绍了Maven报错之导入Junit包来实现@Test注解问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-11-11
  • SpringCloud的全链路灰度发布方案详解

    SpringCloud的全链路灰度发布方案详解

    这篇文章主要介绍了SpringCloud的全链路灰度发布方案详解,灰度发布(又名金丝雀发布)是指在黑与白之间,能够平滑过渡的一种发布方式,灰度发布可以保证系统的稳定性, 在初始灰度的时候可以发现, 调整问题, 保证其影响度,需要的朋友可以参考下
    2023-09-09
  • Java随机数的5种获得方法(非常详细!)

    Java随机数的5种获得方法(非常详细!)

    这篇文章主要给大家介绍了关于Java随机数的5种获得方法,在实际开发中产生随机数的使用是很普遍的,所以在程序中进行产生随机数操作很重要,文中通过图文介绍的非常详细,需要的朋友可以参考下
    2023-10-10
  • Java环境配置图文教程(推荐)

    Java环境配置图文教程(推荐)

    下面小编就为大家带来一篇Java环境配置图文教程(推荐)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2017-09-09
  • Sublime Text 打开Java文档中文乱码的解决方案

    Sublime Text 打开Java文档中文乱码的解决方案

    这篇文章主要介绍了Sublime Text 中文乱码的解决方案,帮助大家更好的理解和使用Java,感兴趣的朋友可以了解下
    2020-12-12
  • Java中的四种单例模式浅析

    Java中的四种单例模式浅析

    这篇文章主要给大家介绍了关于Java中四种单例模式的相关资料,其中包括饿汉式、懒汉式、懒汉式(双重锁)及内部类等四种,分别给出了详细的示例代码和介绍,需要的朋友们下面来一起看看吧。
    2017-05-05

最新评论