java-继承

最新推荐文章于 2022-06-15 18:03:40 发布

原创最新推荐文章于 2022-06-15 18:03:40 发布 · 219 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#继承

java 专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了Java中的继承概念，包括继承的格式、特点、成员变量的关系等，并讲解了如何使用super关键字以及构造方法的关系。此外，还深入探讨了重写的概念、注意事项及final关键字的使用。

继承

1.继承的基础

1.1为什么需要继承

class Student{
	String name;
	int age;
	public Student() {
	}
	public void eat() {
		System.out.println("吃饭");
	}
}
class Teacher{
	String name;
	int age;
	public Teacher() {
	}
	public void eat() {
		System.out.println("吃饭");
	}
}
//我们观察上面的代码 发现 name,age成员变量 eat（）都是相同的
//如果以后继续定义 工人,军人,护士......
//我们每次定义的时候都需要重新写一遍
//偷懒
//我们这样想，我们能不能把相同的内容放到一个独立的类里面
//其它的类和产生关系 父子继承遗产
//让多个类与这个独立的类产生关系
//多个类就可以具备这个独立类的功能
//为了实现这个关系 java提供了技术 继承
public class Demo01 {

}

1.2继承的格式

//父亲
//3个儿子
//继承怎么表示? 继承的格式是怎样的?
class Fu{
	//公共的代码(财产)
}
//extends 继承
class Zi extends Fu{

}
class Person{
	String name;
	int age;
	public void eat() {
		System.out.println("吃饭");
	}
}
class Teacher extends Person{
	public Teacher() {
	
	}
}
public class Demo01 {
	public static void main(String[] args) {
		//如果我们遇到多个类有相同的属性和方法的时候
		//我们可以把这些相同的属性和方法放入一个独立的类中
		//其它类只要用extends关键字继承就可以了
		Student s1=new Student();
		s1.eat();
		Teacher t1=new Teacher();
		t1.eat();
	}
}

1.3优缺点

优点:提高了代码的复用性
提高了代码的维护性
让类与类产生了关系，是多态的前提
缺点:
类与类产生了关系 继承的弊端
类的耦合性增强了
开发 低耦合，高内聚
耦合:类与类的关系
内聚:就是自己完成某件事情的能力

1.4继承的特点

java只支持单继承,不支持多继承
java支持多层继承

class GrandPa{
	public void show() {
		System.out.println("show");
	}
}
class Father extends GrandPa{
	public void aa() {
		System.out.println("我是爸爸");
	}
}
class Monter {

}
class Son extends Father{

}
//Java只支持单继承，不支持多继承
//Java支持多层继承
public class ExtendsDemo01 {
	public static void main(String[] args) {
		Son son=new Son();
		son.aa();
		son.show();
	}
}

class Father{
	private int num=10;
	public int num2=99;
	private void aa() {
		System.out.println("爸爸私有的行为");
	}
	public void show() {
		System.out.println(num);
		System.out.println(num2);
		System.out.println("公有的行为");
	}
}
class Son extends Father{
	public void function() {
		//不能继承私有的属性
		//System.out.println(num);
		System.out.println(num2);
		//不能继承私有的方法
		//show();
	}
}
//A:子类只能继承父类所有的非私有成员(成员变量和成员方法)
//B:子类不能继承父类的构造方法
//C:不要为了部分功能去继承
// 什么时候用继承 is a
// Person Student
// Teacher
// 水果 苹果 采用假设法 如果A和B 他们只要符合A是B的一种,B是A
//的一种 考虑继承
public class ExtendsDemo01 {
	public static void main(String[] args) {
		Son son=new Son();
		son.show();
		son.function();
	}
}

Animal
Dog
Cat

1.5继承成员变量的关系

//继承关系:
//A:子类的成员变量和父类的成员变量不一样 很简单
//B:子类的成员变量和父类的成员变量名称一样
//在子类中的查找顺序
// a:在子类的局部范围查找，有就使用
// b:在子类的成员范围查找，有就使用
// c:在父类的成员的范围查找,有就使用
// d:如果还没有找到,报错
class Father{
	public int num=10;
	public void method() {
		int num=50;
	}
}
class Son extends Father{
	public int num=30;
	public int num2=20;
	public void show() {
		//int num=60;
		System.out.println(num);//
		System.out.println(num2);
	}
}
public class ExtendsDemo {
	public static void main(String[] args) {
		Son son=new Son();
		son.show();
	}
}

1.6super关键字

//这个方案就是java提供一个关键字,super,它可以直接访问父类的数据 super
//this代表对象的引用
//super就代表父类对象的引用
//A:调用成员变量
// this.成员变量 访问当前对象的成员变量
// super.成员变量 访问父类对象的成员变量
//B:调用成员方法
// this.成员方法(参数) 调用当前对象的方法
// super.成员方法(参数) 调用父类对象的方法
//C:调用构造方法
//this(参数) 调用当前对象的构造方法
//super(参数) 调用父类对象的构造方法
class Father{
	public int num=10;
	public void method() {
		int num=50;
	}
}
class Son extends Father{
	public int num=30;
	public int num2=10;
	public void show() {
		int num=90;
		System.out.println(num);//局部 90
		System.out.println(this.num);//成员 30
		//访问父类的num这个变量
		System.out.println(super.num);//10
	}
}
public class ExtendesDemo {
	public static void main(String[] args) {
		Son son=new Son();
		son.show();
	}
}

1.7super在成员方法的使用

当子类和父类出现相同的方法的时候，子类的其它方法在使用这个方法的时候是就近原则
如果想访问父类的这个成员方法加上super关键字

//这个方案就是java提供一个关键字,super,它可以直接访问父类的数据 super
//this代表对象的引用
//super就代表父类对象的引用
//A:调用成员变量
// this.成员变量 访问当前对象的成员变量
// super.成员变量 访问父类对象的成员变量
//B:调用成员方法
// this.成员方法(参数) 调用当前对象的方法
// super.成员方法(参数) 调用父类对象的方法
//C:调用构造方法
//this(参数) 调用当前对象的构造方法
//super(参数) 调用父类对象的构造方法
class Father{
	public int num=10;
	public void method() {
		int num=50;
	}
	public void say() {
		System.out.println("儿子");
	}
}
class Son extends Father{
	public int num=30;
	public int num2=10;
	public void say() {
		System.out.println("hello world!");
	}
	public void method() {
		//就近原则
		//this.say();
		super.say();
	}
	public void show() {
		int num=90;
		System.out.println(num);//局部 90
		System.out.println(this.num);//成员 30
		//访问父类的num这个变量
		System.out.println(super.num);//10
	}
}
public class ExtendesDemo {
	public static void main(String[] args) {
		Son son=new Son();
		son.method();
	}
}

如果要访问父类的成员就加上super

1.8继承中构造方法的关系

class Father {
	int age;
	public Father() {
		age=100;
		System.out.println("父类的无参构造 ");
	}
	public Father(int age) {
		this.age=age;
		System.out.println("Father有参构造方法");
	}
}
//1.子类所有的构造方法都会默认访问(调用)父类的无参构造方法
//为什么? 因为子类继承父类的数据，可能会使用父类的数据
//所以 在子类初始化之前，一定要对父类的数据进行初始化
//注意: 在类每一个构造方法的第一行默认都是super();
// super关键字必须写在构造方法的第一行
//1.构造方法是不能继承的
//2.不管调用子类的是有参构造还是无参构造，都会先执行父类的无参构造
//3.可以在子类构造器代码第一行手动调用父类的有参构造
class Son extends Father{
	public Son() {
		super();
	}
	public Son(int age) {
		super(age);
	}
}

public class ExtendDemo {
	public static void main(String[] args) {
		new Son();
		Son son = new Son(100);
		System.out.println(son.age);//100
	}
}
class Animal {
	private String name;
	private int age;
	private String color;
	public Animal() {
		System.out.println("父类的无参构造器");
	}
	public Animal(String name, int age, String color) {
		this.name = name;
		this.age = age;
		this.color = color;
	}
	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;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
}
//1.构造方法是不能继承的
//2.子类所有的构造方法的第一行会默认调用父类的无参构造
//3.我们可以通过手动的方法调用父类其它有参的构造函数
class Dog extends Animal{
	public Dog() {
		super();
	}
	public Dog(String name, int age, String color) {
		super(name, age, color);
	}
}

public class ExtendDemo02 {
	public static void main(String[] args) {
		Dog dog=new Dog("小狗",1,"白色");
	}
}

1.9面试题

class Fu{
	public int num=10;
	public Fu() {
		System.out.println("fu");
	}
}
class Zi extends Fu{
	public int num=20;
	public Zi() {
		System.out.println("zi");
	}
	public void show() {
		int num=30;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}
public class ExtendTest {
	public static void main(String[] args) {
		// 输出程序的打印结果
		Zi zi=new Zi();
		zi.show();
		//fu zi 30 20 10
	}
}

class Fu{
	public int num=10;
	static{
		System.out.println("静态代码块Fu");
	}
	{
		System.out.println("构造代码块Fu");
	}
	public Fu() {
		System.out.println("fu");
	}
}

class Zi extends Fu{
	static{
		System.out.println("静态代码块Zi");
	}
	{
		System.out.println("构造代码块Zi");
	}
	public int num=20;
	public Zi() {
		System.out.println("zi");
	}
}

public class ExtendTest {
	public static void main(String[] args) {
		// 输出程序的打印结果
		Zi zi=new Zi();
		//1.先执行静态代码块 先父后子
		//2.父类的构造代码块->父类的构造方法->子类的构造代码块->构造方法
	}
}

2.重写

2.1重写的概念

重载一个类中，方法的名字相同，参数个数或者类型不同，和返回值无关系

class Phone{
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}
class HuaWei extends Phone{
	//重新写一遍
	public void call(String name) {
		super.call(name);
		System.out.println("给"+name+"短信");
	}
}
	//子类重写了父类的方法，调用的是子类的方法
	//子类出现了和父类方法声明一模一样的方法(包括返回值类型)
public class PhoneTest {
	public static void main(String[] args) {
		HuaWei huaWei=new HuaWei();
		huaWei.call("班长");
	}
}

Override: 覆盖方法重写
Overload:方法的重载
Override和Overload的区别?

2.2重写的注意事项

class Phone{
	public void show() {
		System.out.println("show");
	}
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}
	//1.父类的私有方法不能重写 因为父类的私有方法子类根本无法继承
	//2.子类重写父类方法的时候 权限不能更低 最好一样
	class HuaWei extends Phone{
	@Override//检测父类有没有这个方法 可写可不写
	public void show() {
	}
	//重新写一遍
	public void call(String name) {
		super.call(name);
		System.out.println("给"+name+"短信");
	}
}
	//子类重写了父类的方法，调用的是子类的方法
	//子类出现了和父类方法声明一模一样的方法(包括返回值类型)
public class PhoneTest {
	public static void main(String[] args) {
		HuaWei huaWei=new HuaWei();
		huaWei.call("班长");
	}
}

2.3final

/**
* final 最终的 可以修饰类,方法，变量
* 1.被final修饰的类无法被继承
* 2.被final修饰的方法不能被重写
* 3.被final修饰的变量，这个变量不能重新被赋值 常量
*/
class Fu{
	//常量
	public final int num=10;
	public final void show() {
		System.out.println("好好学习，天天向上!");
	}
}

class Zi extends Fu{

}
public class ExtendDemo {
	public static void main(String[] args) {
		Zi zi=new Zi();
		zi.show();
	}
}