Java类的继承

我爱吃非常荷包蛋

已于 2023-12-21 15:25:04 修改

阅读量1.4k

点赞数 35

文章标签： java 开发语言

于 2023-11-30 09:59:43 首次发布

本文链接：https://blog.csdn.net/2301_77070523/article/details/134704278

版权

本文详细介绍了Java中的类继承机制，包括如何声明和使用派生类，构造方法的调用顺序，成员变量的隐藏与覆盖，以及super和this关键字的作用。还涵盖了对象类型转换和终极方法、终极类的概念，强调了Java学习的系统性和逐步深入的重要性。

摘要由CSDN通过智能技术生成

类的继承

在日常生活中，大家都能够理解类的概念。例如：动物类。它可以进一步细分为很多子类，狗、猫、老虎、狮子等等。这些子类共同都属于动物这个大类，都继承了动物共同的特性，同时又具有各自的特点。

继承也被用于程序设计中，在现有类（称为父类或基类）上建立新类（称为子类或派生类）的处理过程即为继承。

利用继承类，可以实现代码的重用。即当一个类从另一个类派生出来时，派生类就自然具有了基类数据成员、方法成员等，基类定义中这些成员代码，就不需要在派生类定义中重写，在派生类的定义中，只需书写基类定义中所不具有的代码即可。

在Java中，所有的类都是通过直接或间接的继承Object类得到的。

声明派生类的一般形式如下：

[访问修饰符] class 类名 extends 基类 {

类的成员；

}

继承使用示例

//基类
public class Person {
	protected String name;//姓名
	protected String sex;//性别
	protected String age;//年龄
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	public String geetInfo() {
		return "姓名="+name+",性别="+
					sex+",年龄="+age;
	}
}

//派生类
public class Student ex Person {
	private String id;//学号
	private int score1;//成绩1
	private int score2;//成绩2
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public int getScore1() {
		return score1;
	}
	public void setScore1(int score1) {
		this.score1 = score1;
	}
	public int getScore2() {
		return score2;
	}
	public void setScore2(int score2) {
		this.score2 = score2;
	}
	public int total() {//计算总分
		return score1+score2;
	}
	public double average() {//计算平均分
		return (score1+score2)/2.0;
	}
}

	public static void main(String[] args) {
		Person p1=new Person();
		p1.setAge(30);
		p1.setName("张三");
		p1.setSex("男");
		System.out.println(p1.getInfo());
		
		Student stud1=new Student();
		stud1.setName("李四"); //访问父类的成员
		stud1.setSex("女");
		stud1.setAge(20);
		stud1.setId("20220322000");//访问子类成员
		stud1.setScore1(90);
		stud1.setScore2(89);
		
		System.out.println(stud1.getInfo());//访问父类成员
		System.out.println("两科成绩总分为："+stud1.total());//访问子类的方法
		System.out.println("两科成绩平均分为："+stud1.average());//访问子类的方法
	}
}

派生类构造方法：

在Java中，派生类不能继承其基类的构造方法。

在创建派生类对象时，先调用基类构造方法，再调用派生类自己的构造方法。

默认调用基类无参构造方法。

使用super关键字调用基类有参构造方法。

格式： super（参数列表）

请分析一下程序运行结果：

class Father{
    String s = "father";
    public Father() {
        System.out.println(s);
    }
    public Father(String str) {
        s = str;
        System.out.println(s);
    }
}

class Son extends Father {
    String s = "son";
    public Son() {
        System.out.println(s);
    }
}

public class Myclass4 {
    public static void main(String args[]) {
        Father obfather1 = new Father();
        Father obfather2 = new Father("hello");
        Son obson1 = new Son();
    }
}

运行结果如下：

通过super关键字调用基类有参构造方法。

public class Person {
	protected String name;
	protected String sex;
	protected int age;
.....
    public Person(){
    }

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

public class Student ex Person {
	private String id;
	private int score1;
	private int score2;
    ...
    public Student(){
    }
    public Student(String name,String sex,byte age
            ,String id,int score1,int score2){
            super(name,sex,age);
            this.id=id;
            this.score1=score1;
            this.score2=score2;
    }
    ...
}

调用基类有参构造方法要显示说明，必须是第一个语句。

public class Program{
    public static void main(String[] args) {
    Person p1=new Person();
    p1.setAge(30);
    p1.setName("李四");
    p1.setSex("女");
    System.out.println(p1.getInfo());
    Student stu1=new Student("张三","男",20,"20110450001",90,80);
    System.out.println(stu1.getInfo());
    System.out.println("两科成绩总分为："+stu1.total());// 访问子类的方法
    System.out.println("两科成绩平均分为："+stu1.average());// 访问子类的方法
    }
}

成员的隐藏与覆盖

类的继承中，派生类继承了基类的所有成员（构造方法除外）。

当子类定义的成员变量与父类成员变量同名时，子类隐藏父类的成员变量，即在默认情况下，子类使用自己的成员变量。

当子类定义的方法与父类方法同名、参数一致时，子类覆盖（重写override）父类方法，即在默认情况下，引用子类自己的方法。

成员变量隐藏示例

分析程序运行结果

class FAther {
	String s="father";
	public FAther() {
		System.out.println(s);
	}
	public FAther(String str) {
		s=str;
		System.out.println(s);
	}
}
class Son extends FAther{
	String s="son";
	
	publicSon(){
		System.out.println(s);
	}
}
public class Myclass{
	public static void main(String args[]) {
		FAther obfather1 =new FAther();
		FAther obfather2=new FAther("hello");
		Son obson1=new Son();
	}
}

运行结果为：

super关键字示例

一、super代指一个对象的父类/基类。

二、super的作用：

1.调用父类构造方法。

2.取父类中被子类隐藏了的成员变量。

3.取被子类覆盖了的方法。

三、super关键字调用语法：

1.调用父类成员变量：super.成员变量名

2.调用父类构造方法：super（参数列表）

3.调用父类方法：super.父类方法();

this关键字

一、this代表当前对象。

二、this的作用：

1.可以调用本类的非静态方法和成员变量。

2.this关键字还可以调用本类中的构造方法。

三、this关键字调用语法：

1.this.成员变量名

2.this.方法名（参数表）

3.this（参数） //引用本类的构造方法

对象类型的转换

public class Animal{//动物类
	public void sleep() {//描绘动物睡觉的方法
		System.out.println("all animal need sleep");
	}
}
public class Fish extends Animal{//鱼类，继承动物类
	public void sleep() {
		System.out.println("fish sleeping with eye_open");
	}
}
public class Dog extends Animal{//狗类，继承动物类
	public void sleep() {
		System.out.println("dog  sleeping with eye_close");
}
public class Program{
	public static void main(String[] args) {
		Animal a=new Animal();
		Animal f=new Fish();//向上转型
		Animal d=new Dog();//向上转型
		a.sleep();
		f.sleep();
		d.sleep();
	}
}

向上转型：将子类对象转换为父类对象，隐式转换。

向下转型：将父类对象转换为子类对象，需要显示转换。

如果父类对象不是子类的一个实例，向下转型不成功，会抛出类型转换异常。

public class Program{
	public static void main(String[] args) {
		Animal a=new Animal();
		Animal f=new Fish();//向上转型
		Animal d=new Dog();//向上转型
		a.sleep();
		f.sleep();
		d.sleep();
		if (a instanceof Dog) {
			Dog newD=(Dog) a;//向下转型
			newD.sleep();
		}
		if (f instanceof Fish) {
			Fish newF=(Fish) f;//向下转型
			newF.sleep();
		}
	}
}

instanceof:用于判断一个对象是否属于一个类，如果是则返回true,否则返回false。

终极方法

为了防止父类方法被覆盖，确保程序的安全有效运行，可以使用终极方法，即在方法前使用final关键字。

public class Animal{//动物类
    public final void sleep(){
        System.out.println("all animal need sleep");
    }
}

public class Fish extends Animal{//鱼类，继承动物类
    public final void sleep(){
        System.out.println("fish sleeping with eye_open");
    }
}

如果父类方法为终极方法，子类试图重写该方法，会抛出异常。

终极类

为了阻止一个类的代码被其他类继承，就可以使用终极类，即在类前使用final关键字。

如：

public final class Animal{

......

}

则Dog类就无法继承Animal类，其所有代码需要重新书写。

总结：

学习java应该要循环渐进,有始有终,按部就班,脚踏实地。java是一门有着阶梯性的一们语言,如果要学习它。我觉得最好还是按照java的学习体系,先学习什么,在学习什么,只有这样,我们在学习中才会遇到更少的麻烦。

我爱吃非常荷包蛋

关注

35
点赞
踩
33

收藏

觉得还不错? 一键收藏
5
评论
Java类的继承

在日常生活中，大家都能够理解类的概念。例如：动物类。它可以进一步细分为很多子类，狗、猫、老虎、狮子等等。这些子类共同都属于动物这个大类，都继承了动物共同的特性，同时又具有各自的特点。继承也被用于程序设计中，在现有类（称为父类或基类）上建立新类（称为子类或派生类）的处理过程即为继承。利用继承类，可以实现代码的重用。即当一个类从另一个类派生出来时，派生类就自然具有了基类数据成员、方法成员等，基类定义中这些成员代码，就不需要在派生类定义中重写，在派生类的定义中，只需书写基类定义中所不具有的代码即可。
复制链接

扫一扫