面向对象(二):继承+多态+异常

最新推荐文章于 2024-02-01 10:26:33 发布

qq_49281675

最新推荐文章于 2024-02-01 10:26:33 发布

阅读量169

点赞数

分类专栏： JAVA基础文章标签： java

本文链接：https://blog.csdn.net/qq_49281675/article/details/109500217

版权

JAVA基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.继承

1.1 概述

继承是面向对象最显著的一个特性。
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。
这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。
提高复用性：只要继承父类，就能有一样的功能

1.2 特点

1、使用extends关键字
2、相当于子类把父类的功能复制了一份
3、 java只支持单继承
4、继承可以传递（爷爷，儿子，孙子的关系）
5、不能继承父类的私有成员
6、继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、像是is a 的关系(强制的依赖关系)

测试一:
人门

测试二:
继承可以传递（爷爷，儿子，孙子的关系）

1.3 super关键字(类似this关键字)

1,super表示父类对象的一个引用.底层会帮你创建一个父类对象
2,super在子类里使用,用来调用父类的功能
3,如果要在构造方法中,使用super关键字,必须是一条语句

1.4 方法重写(override)

–1,发生在继承结构中
–2,当子类继承了父类后,想修改父类的原有功能,这时就发生了方法重写
–3,要求:子类中的方法签名/方法声明必须和父类的一模一样
–4,方法声明: ? 返回值方法名(参数列表)
–5,注意在子类中想要重写父类的方法,必须有足够的权限 >= 父类权限

1.5 继承中的用法

1.5.1 成员变量的用法------->supper

1.5.2 成员方法的用法

package cn.tedu;
//测试继承中的成员方法
public class Test01 { 
	public static void main(String[] args) {
		Zi z = new Zi();
		z.eat();//重写之前使用父类的功能;重写之后使用自己的功能
		z.play();//z子类自己的功能扩展
	}
}
class Fu{
	public void eat() {
		System.out.println("爸爸在吃肉肉");
	}
}
class Zi extends Fu{
	//1.子类可以使用父类的功能
	//2.子类可以进行功能扩展
	public void play() {
		System.out.println("打台球");
	}
	//3.子类还可以修改父类的原有功能--->方法的重写,要求方法的声明必须和父类保持一致
	@Override
	public void eat() {
		super.eat();//调用父类的方法;虽然发生了方法的重写,但对父类的功能没有任何影响
		System.out.println("儿子在喝汤");
	}
}

1.5.3 构造方法的用法

小结:
1,子类的构造方法里 ,隐藏着 super(),也就是说,会自动调用父类的无参构造
2,构造方法执行顺序: 父类的构造 > 子类的构造
3,如果父类中只提供了含参构造,此时,父类里就没有无参构造了.子类的super()就报错,只能调用父类的含参构造

package cn.tedu;
//测试继承中的构造方法
public class Test01 { 
	public static void main(String[] args) {
		//2,创建子类对象时,会自动调用 子类的构造方法....但是藏着super(),,,就先去调用了父类的构造方法
		Zi2 zi = new Zi2();
		//5,创建子类对象时,发生两件事:  先把父类对象创建好,然后才去创建的子类对象..因为先执行父类的构造方法然后才执行子类的构造方法.
		
	}
}
//创建父类
class Fu2{
	//提供构造方法
//	public Fu2() {
//		System.out.println("父类的 无参构造方法");
//	}
	//4.1, 子类会默认调用父类的无参构造.但是,如果父类没有无参构造呢???---只能调用 父类的含参构造
public Fu2(String name) {
	System.out.println("父类的 含参构造方法"+name);
	}
}
//创建子类
class Zi2 extends Fu2{
	//提供构造方法
	public Zi2() {
		//1,子类的构造方法中,  隐藏了 一行代码  super()  ,  去调用了父类的无参构造.
		//3,如果在构造方法中,出现super关键字,必须是第一条语句!!!
//		super();
		
		//4, 子类会默认调用父类的无参构造.但是,如果父类没有无参构造呢???---只能调用 父类的含参构造
		super("jack");
		System.out.println("子类的 无参构造方法");
	}
	
}

1.6 this和super的区别

1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，因为他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。

1.7 重写与重载的区别（Overload和Override的区别）

1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现

2.static 关键字

2.1概述

用于修饰成员(成员变量和成员方法)

2.2 测试

测试一:

package cn.tedu;
//测试static
public class Test01 { 
	public static void main(String[] args) {
		Person p = new Person();
		p.play();
		System.out.println(p.name);
		//2.如何调用静态资源
		//2.1 静态资源的访问方式1: 可以通过对象的方式调用(不提倡).
		p.show();
		System.out.println(p.age);
		//2.2 静态资源的访问方式2: 最好使用静态方式访问静态资源 --- 类名直接调用
		Person.show();
		System.out.println(Person.age);
		//3.静态资源是全局的共享资源,在多个对象间共享
		Person p2 = new Person();
		Person p3 = new Person();
		p2.age=10;
		System.out.println(p3.age);//10,说明age在p2,p3间共享
	}
}
class Person{
	//普通资源
	String name;
	public void play() {
		System.out.println("这是普通方法");
	}
	
	//静态资源
	//1.static可以用来修饰成员变量和成员方法,修饰方法时可以放在修饰符(public)的前面也可以放在修饰符的后面
	static int age;
	static public void show() {
		System.out.println("这是静态方法");
	}
}

测试二:
非静态资源可以任意调用
静态资源只能调用静态资源

3.代码块—>静态代码块,构造代码块,局部代码块

3.1 概述

静态资源只会加载一次,会随着类的加载而加载,第一时间加载到内存中,并一直贮存在内存中,直到类消失,静态资源才消失

3.2 测试

3.3 总结

执行循序:静态代码块>构造代码块>局部代码块

总结:
1,静态代码块 : 作用是第一时间加载+只加载一次 + 常用来完成项目的初始化 + 触发的时间节点是当类被第一次加载时
2,构造代码块 : 作用是提取构造方法的共性 + 触发的时间节点是当创建对象时
3,局部代码块 : 作用是控制变量的作用范围 + 触发的时间节点是方法调用时
4,执行顺序 : 当类第一个被加载时,立刻加载静态代码块…当类被实例化时会加载构造代码块和构造方法…当方法被调用时加载局部代码块

4. final 关键字

4.1 概述

4.2 测试

package cn.tedu;
//测试final
public class Test01 { 
	public static void main(String[] args) {
		FinalDemo demo = new FinalDemo();
//		demo.name = "" ; The final field FinalDemo.name cannot be assigned
		System.out.println( demo.NAME );//访问静态资源方式1
		System.out.println(FinalDemo.NAME);//访问静态资源方式2
		demo.eat();
	}
}
//1 , 被final修饰的类,是最终的类 --- 不能被继承!!!  The type ZiFinal cannot subclass the final class FinalDemo
//final class FinalDemo{ 
class FinalDemo{
	
	//3,final修饰的成员变量是常量---值不能被修改!!! The final field FinalDemo.name cannot be assigned
	//常量通常为了方便外界调用,都会被static修饰.可以直接被类名访问
	static final String NAME = "玛利亚" ; 
	
	//2 , final修饰的方法是最终方法 --- 不能被重写(可以继承使用,不能被重写修改)!!!Cannot override the final method from FinalDemo
//	final public void eat() {
	public void eat() {
		System.out.println("正在吃饭");
	}
}
class ZiFinal extends FinalDemo{
	//方法重写
	public void eat() {
		System.out.println(123);
	}
}