首页 > 其他分享> 文章详细

2021-07-06继承

2021-07-06 19:03:52 阅读：147 来源： 互联网

标签：06 07 子类 void class 2021 Animal 父类 public

继承

1.继承是从已有类中,派生出新的类,新的类拥有父类的属性和行为,并且还能扩展新的属性和行为

2.Java中只支持单继承,不支持多继承,这样可以让Java中的继承关系比较简单

一个类只能有一个父类,但是一个父类可以有很多子类,易于维护和管理

为了解决单继承功能变弱问题,Java提出了接口,一个类可以实现多个接口

3.继承是可以传递的,比如A继承B,B继承C ,则A也会拥有C的功能

4.私有属性和构造方法是不能被继承

5.如果一个类没有显示继承其他类,则该类提供Object

Java.lang.Object是Java提供的根类(祖宗)

Object中的功能,是所有类对象都有的

解决的问题

提高了代码的效率,避免了代码的重写,提高代码重用性

语法

[修饰符] class 子类名 extends 父类名{ }

public class Extends_01 {
	public static void main(String[] args) {
			Sub sub = new Sub();
			sub.m1();
			sub.m2();
	}
}
class Sup{
	public void m1(){
		System.out.println("父类的m1方法");
	}
}
class Sub extends Sup{
	public void m2(){
		System.out.println("子类的m2方法");
	}
}

super

1 官方说法是保存了父类型特征

2 在有继承关系的体系中,可以通过super表示父类的数据

能做什么

1 用在成员/构造方法中,区分父类和子类同名的数据(同名后,子类优先级高,想使用父类,就需要使用super.xxx才行)
*        2 用在子类构造方法中,调用指定的父类构造方法
*                语法 : super(参数) ; 必须在子类构造方法第一行
*                如果子类构造方法中没有使用 this(xxx) 也没有使用 super(xxx) 则有一个 super() 去调用父类的无参构造
*                this(xxx) 和 super(xxx) 都必须出现在构造方法第一行,也就意味着它们两个不能同时出现
*        3 this和super 都不能出现在静态上下文中

用法

区分父子类同名属性

public static void main(String[] args) {
		Sub sub = new Sub();
		sub.print();
	}
}
class Sup{
	int i = 10;
}
class Sub extends Sup{
	int i = 20;
	public void print(){
		int i = 30;
		// 局部变量优先级高
		System.out.println(i);
		// this区分同名局部和成员
		System.out.println(this.i);
		// super区分父子类同名属性
		System.out.println(super.i);
	}
}

调用父类指定构造方法

public static void main(String[] args) {
		Sub_01 s = new Sub_01();
		
	}
}
class Sup_01{
	// 父类实例,父类构造,子类实例,子类构造
	{
		System.out.println("父类实例语句块");
	}
	Sup_01(int i){
		System.out.println("父类构造方法");
	}
}
class Sub_01 extends Sup_01{
	{
		System.out.println("子类实例语句块");
	}
	Sub_01(){
		// 默认就会有super() 去调用父类的无参构造
		super(2);
		System.out.println("子类构造方法");
	}
}

class Sup_02 {
	// 构造方法私有化之后,就不能再被继承了
	// 因为子类构造方法中需要调用父类构造方法,一旦私有化,就会因为权限问题访问不了
	private Sup_02() {
		super();
	}
}

override

是什么

Override 是方法重写/覆写/覆盖 , 覆写特指成员方法,除了成员方法,其他的都不能覆写

应用场景

1 什么时候需要对父类方法进行覆写
*                当父类的功能满足不了子类需求的时候
*        2 覆写条件
*                2.1 有继承关系的体系中
*                2.2 方法名必须一致,如果方法名不一致,就是两个方法了
*                2.3 参数列表必须一致,如果参数列表不一致,这是方法重载,也是两个方法
*                2.4 返回值必须一致
*                2.5 不能有更宽泛的异常(异常只能越来越少)
*                2.6 不能有更低的访问权限
*        3 覆写的意义
*                功能越来越强
*                使用范围越来越广
*                错误越来越少
*

public static void main(String[] args) {
		Cat cat = new Cat();
		cat.move();
	}
}
class Animal{
	public void move(){
		System.out.println("动物在移动");
	}
}
class Cat extends Animal{
	// @Override是源码注解,在编译的时候,判断该方法是否是覆写的方法,防止写错,仅此而已,生成class之后该注解就会被去掉
	// 如果不加,比如方法名写错了,那么最多也就是两个方法,不会报错,但是加上@Override就会进行校验操作
	@Override
	// 父类满足不了子类的需求 需要进行重写
	public void move() {
		System.out.println("猫在跳");
	}
}

final

是什么

final : 是修饰符,表示最后的,最终的,不可更改的
*
* 类 : final修饰的类不能被继承
*
* 变量 : 没有默认值,不能二次赋值,必须显式赋值(不能有不赋值的情况)
*
* 方法 : final修饰的成员方法不能被覆写
*
* final 修饰的静态变量,一般称为常量 , public static final xxxx; 常量名建议全部大写

怎么用

public class Final_01 {
	// final修饰 没有默认值
	final int age;
	public static final String NAME = "xx";
	Final_01() {
		// 不能二次赋值
		// age = 1;
		age = 2;
	}

	public static void main(String[] args) {

	}
}
final class A{
	
}
// 不能从最终A 进行继承
//class B extends A{
//}
class B {
	public final void m1(){
		
	}
}

class C extends B {
	// final修饰的成员方法不能被覆写
	// @Override
	// public void m1() {
	// }
}

public static void main(String[] args) {
		final int age = 1;
		// 不能二次赋值
		// age = 2;

		// final修饰的user
		final User user = new User(10);
		// 而age并没有加final修饰,我们也并没有更改user的值,所以可以更改age
		user.age = 13;
		System.out.println(user.age);
		// 但是不能再次更改user的值
		// user = null;
	}
}

class User {
	int age;

	public User(int age) {
		super();
		this.age = age;
	}

多态

什么是多态

多态就是里氏替换原则的一种体现
*                能使用父类的地方就一定可以使用子类
*
*        多态就是父类引用指向子类对象
*            父类引用 : 使用父类类型创建的引用类型变量
*            指向 : 通过这个引用可以找到谁
*            通过父类创建的一个引用类型变量,找到了子类的对象
*            父类类型变量名 = new 子类();
*            Animal a = new Animal();
*            Animal a = new Cat() ; 多态
*
*        有变量的地方,就能发生多态,并且多态发生在赋值的时候
*
*        多态的缺点 : 丢失子类特有的属性

多态的几种形式

1 直接多态 : 父类变量 = new 子类();
*        2 形参/实参 : 参数列表用父类声明, 调用方法传递子类对象
*                public void m1(Animal a){}
*                m1(new Cat());
*        3 返回值多态 : 返回值类型是父类类型,但是返回的对象是子类对象
*                public Animal m2(){
*                    return new Cat();
*                }
*                Animal a = m2();

多态进行属性调用

1 父类没有的,都调用不了(因为多态缺点,丢失子类特有的属性)
* 2 父类有的,子类没有的,执行父类
* 3 父类和子类都有,除了成员方法执行子类,其他全部执行父类(因为只有成员方法可以覆写)

public static void main(String[] args) {
		// 直接多态
		Animal a = new Cat();
		
		
		// 返回值多态
		Animal i = m1();
		
		// 形参实参多态
		m2(new Cat());
	}
	public static void m2(Animal a ){
	}
	public static Animal m1(){
		return new Cat();
	}
	
}
class Animal{
	
}
class Cat extends Animal{
	
}
class Dog extends Animal{
	
}

例子

public class Poly_02 {
	public static void main(String[] args) {
		Dog_1 d = new Dog_1();

		test(d);

		Cat_1 c = new Cat_1();
		test(c);
	}

	// 需求 : 编写方法,要求能够接收所有的对象,并调用该对象的move方法
	// 如果后续想接收其他动物,就需要改动源码,扩展性不强
	// public static void test(Cat_1 cat) {
	// cat.move();
	// }
	//
	// public static void test(Dog_1 dog) {
	// dog.move();
	// }
	
	// 多态形式,只要传递的对象是Animal_1的子类都是可以的
	// 所以后续想接收其他动物,这里也不需要改动,更能拥抱变化
	 public static void test(Animal_1 animal_1) {
		 animal_1.move();
	 }
}

class Animal_1 {
	public void move() {
	}
}

class Cat_1 extends Animal_1 {
	public void move() {
		System.out.println("猫走猫步");
	}
}

class Dog_1 extends Animal_1 {
	public void move() {
		System.out.println("狗蹦蹦跳跳");
	}
}

标签：06,07,子类,void,class,2021,Animal,父类,public
来源： https://blog.csdn.net/weixin_59544199/article/details/118526774

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9