java类的继承

最新推荐文章于 2022-03-24 16:38:46 发布

wo不理智

最新推荐文章于 2022-03-24 16:38:46 发布

阅读量403

点赞数 1

分类专栏： Java基础学习文章标签： java

本文链接：https://blog.csdn.net/weixin_56504344/article/details/116610115

版权

Java基础学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

类的继承

一.继承好处与弊端

1.继承的好处

提高了代码的复用性
提高了代码的维护性
让类与类之间产生关系，是多态的前提

2.继承的弊端

类的耦合性增强了

开发的原则：高类聚，低耦合
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

二.继承特点

java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
有些语言支持多继承，格式：extends 类1,类2,…
java支持多层继承(如DemoA，DemoB，DemoC)
如果想用这个体系的所有功能，就用最底层的类创建对象
如果想看这个体系的共性功能，看最顶层的类
案例演示

public class Demo17_OOP_extends1 {
	public static void main(String[] args) {
	}
}

class DemoA {
	public void show() {
		System.out.println("DemoA");
	}
}

class DemoB extends DemoA {
	public void method() {
		System.out.println("DemoB");
	}
}

class DemoC extends DemoB {
	public void print() {
		System.out.println("DemoC");
	}
}

三.继承的注意事项

子类只能继承父类所有非私有的成员(成员方法和成员变量)
A:案例演示

public class Demo17_OOP_extends2 {
	public static void main(String[] args) {
		Son s1 = new Son();
		s1.show();
	}
}

class Father {
	private String name;
	
	public void show() {
		System.out.println("public可继承");
	}
	
	private void print() {
		System.out.println("private不可继承");
	}
}

class Son extends Father {
}

子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法
不要为了部分功能而去继承
*案例演示
*项目经理姓名工号工资奖金
*程序员姓名工号工资
注意：
不可以让程序员继承项目经理，因为会多出一个成员,也不可以让项目经理继承程序员
正确做法:
找到两者相同的成员，创建类，然后创建这两类，缺什么成员就在本类中补齐

public class Demo17_OOP_extends2 {
	public static void main(String[] args) {
		manager m = new manager();
		m.name = "ljh";
		m.num = "1234567";
		m.salary = 20000;
		m.bonus = 2000;
		
		System.out.println(m.name + " " + m.num + " " + m.salary +" " + m.bonus);
	}
}

class staff {//相同成员
	String name;
	String num;
	int salary;
}

class manager extends staff {
	int bonus;//补成员
}

class monkey extends staff {
}

四.继承中成员变量的关系与调用

一.关系

不同名变量
正常输出
同名变量
就近原则，子类有就不用父类的
注意：
子父类出现同名的变量只是在讲课中举例子有，在开发中是不会出现这种情况的
子类继承父类就是为了使用父类的成员，如果定义了同名的成员变量就没有意义了
案例演示

public class Demo17_OOP_extends3 {
	public static void main(String[] args) {
		Son1 s = new Son1();
		s.print();
	}
}

class Father1 {
	int num1 = 10;
	int num2 = 20;
}

class Son1 extends Father1 {
	int num2 = 30;
	
	public void print() {
		System.out.println(num1);//10
		System.out.println(num2);//30
	    //就近原则，子类有就不用父类的
	}
}

二.this和super的区别和应用

1.this和super都代表什么

this：代表当前对象的引用，谁来调用我，我就代表谁
super：代表当前对象父类的引用

2.this和super的使用区别

调用成员变量

this.成员变量调用本类的成员变量，也可以调用父类的成员变量
super.成员变量调用父类的成员变量

调用构造方法

this(…) 调用本类的构造方法
super(…) 调用父类的构造方法

调用成员方法

this.成员方法调用本类的成员方法，也可以调用父类的成员方法
super.成员方法调用父类的成员方法

案例演示

public class Demo17_OOP_extends3 {
	public static void main(String[] args) {
		Son1 s = new Son1();
		s.print();
	}
}

class Father1 {
	int num1 = 10;
	int num2 = 20;
}

class Son1 extends Father1 {
	int num2 = 30;
	
	public void print() {
		System.out.println(this.num1);//10  this既可以调用本类的，也可以调用父类的(本类没有的情况下)
		System.out.println(this.num2);//30  super可以调用父类的
		//就近原则，子类有就不用父类的
		System.out.println(super.num2);//20
	}
}

五.继承中子类父类构造方法的关系和注意事项

一.关系

子类中所有的构造方法默认都会访问父类中空参的构造方法

为什么呢？

因为子类会继承父类的数据，可能还会使用父类的数据，所以，子类初始化之前，一定会先完成父类数据的初始化
其实，每一个构造方法的第一条语句默认都是：super() ；
Object类最顶层的父类

2 案例演示

public class Demo17_OOP_extends4 {
	public static void main(String[] args) {
		Son3 s = new Son3();
	}
}

class Father3 extends Object {  //Object类最顶层的父类
	public Father3() {
		System.out.println("Father3 的构造方法");
	}
}

class Son3 extends Father3 {
	public Father3() {
		super();//这是一条构造语句，如果不写，系统会自动加上，用来访问父类中的空参构造
		System.out.println("Son3 的构造方法");
	}
}

二.注意事项

父类没有无参构造方法，子类进行无参构造是怎么办？

super解决

super(参数1,参数2,…);调用父类的有参构造方法
（super在构造方法中必须放到第一行）

this解决

子类无参构造中this调用子类中的有参构造，然后子类有参构造中的super调用父类中的有参构造
（this在构造方法中必须放到第一行）

2.案例演示

public class Demo17_OOP_extends5 {
	public static void main(String[] args) {
		Son4 s1 = new Son4();
		System.out.println(s1.getName() + " " + s1.getNum());
		System.out.println("---------------");
		Son4 s2 = new Son4("张三",23);
		System.out.println(s2.getName() + " " + s2.getNum());
	}
}
/*
输出：
Father 有参构造
Son 有参构造
Son 空参构造
王五 25
---------------
Father 有参构造
Son 有参构造
张三 23
*/

class Father4 {
	private String name;
	private int num;

	public Father4(String name,int num) {
		this.name = name;
		this.num = num;
		System.out.println("Father 有参构造");
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
	
	public void setNum(int num) {
		this.num = num;
	}
	
	public int getNum() {
		return this.num;
	}  
}

class Son4 extends Father4 {
	public Son4() {
		//如果想访问父类中的有参构造可以通过super(参数1,参数2)，this(参数1,参数2)
		//super("李四",24);调用父类的有参构造方法
		this("王五",25);//调用子类的有参构造放阀
		System.out.println("Son 空参构造");
	}
	
	public Son4(String name,int num) {
		super(name,num);//子类无参构造中this调用子类中的有参构造，然后子类有参构造中的super调用父类中的有参构造
		System.out.println("Son 有参构造");
	}
}

六.代码块与继承

一.原理
1.jvm调用了main方法，main进栈
2.遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存，再创建对象，当Fu.class加载进内存
父类的静态代码块会随着Fu.class一起加载，当Zi.class加载进内存，子类的静态代码块会随着Zi.class一起加载
第一个输出：静态代码块Fu，第二个输出：静态代码块zi
3.走子类的构造方法，因为java中是分层初始化的，先初始化父类，再初始化子类，所以先走父类构造，但是在执行父类
构造时，发现父类有构造代码块，构造代码块是优先于构造方法的所以
第三个输出：构造代码块fu，第四个输出：构造方法fu
4.Fu类初始化结束，子类初始化
第五个输出：构造代码块zi，第六个输出：构造方法zi
二.案例演示

public class Demo17_OOP_extends6_Code {
	public static void main(String[] args) {
		Zi z = new Zi();
	}
}
/*
输出：
静态代码块 fu
静态代码块 zi
构造代码块 fu
构造方法 fu
构造代码块 zi
构造方法 zi
*/
class Fu {
	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 Zi() {
		System.out.println("构造方法 zi");
	}
}

七.方法重写

一.引入方法重写
1…子父类方法重名如何调用
super.重名方法();
（此时super位于成员方法中位置可以任意放，不需要像构造方法中放到第一位）
2.案例演示

public class Demo17_OOP_extends7 {
	public static void main(String[] args) {
		Zi1 z1 = new Zi1();
		z1.print();
		z1.method();
	}
}
/*
输出：
Zi print
Fu print
Zi method
*/
class Fu1 {
	public void print() {
		System.out.println("Fu print");
	}
}

class Zi1 extends Fu1 {
	public void method() {
		System.out.println("Zi method");
	}
	
	public void print() {
		System.out.println("Zi print");
		super.print();      //super可以调用父类的成员方法
	}
}

二.重写
1.什么是方法重写？

重写：子父类出现了一模一样的方法，在子类中对父类的方法进行重新赋予功能

（注意：返回值类型可以是子父类，这个我们学完面向对象讲）

class person7 {
	public void print() {
		System.out.print("Person");
	}
}

class student7 extends person7 {
	public void print() {
		System.out.print("student");
	}
}

class father7 {
	public person7 method() {
		return new person7();
	}
}

class son7 extends father7 {         //返回值为
	public student7 method() {
		return new student7();
	}
}

2.方法重写的应用

当子类需要父类的功能，而功能主体子类有自己的特有内容时，可以重写父类的方法。这样，既沿袭了父类的功能，又定义了子类特有的内容

3.案例演示
定义一个手机类
ios7系统 siri speak English
ios8系统 siri 说中文

public class Demo17_OOP_extends8_phone {
	public static void main(String[] args) {
		Ios8 i = new Ios8();
		i.siri();
		i.call();
	}
}
/*
输出：
说中文
speak English
打电话
*/
class Ios7 {
	public void call() {
		System.out.println("打电话");
	}
	
	public void siri() {
		System.out.println("speak English");
	}
}

class Ios8 extends Ios7 {
	public void siri() {
		System.out.println("说中文");
		super.siri();//保留父类中的功能，不想保留就删除
	}
}

三.重写的注意事项
1.父类中私有的方法不能重写

因为父类私有方法子类根本就无法继承

2.子类重写父类方法时，访问权限不能更低

最好都一致

3.父类静态方法，子类也必须通过静态方法进行重写

其实这个算不上重写，但是现象确实如此，至于为什么算不上重写，多态中会讲解(静态只能覆盖)

4.子类重写父类方法时，最好声明的一模一样

5.案例演示

public class Demo17_OOP_extends8_phone {
	public static void main(String[] args) {
		Dayone d  = new Dayone();
		d.泡妞();
		d.print();
	}
}
/*
输出：
霸王硬上弓搞定fu女士
Zi print
*/
class 双桨 {
	private void sing() {            //不能重写
		System.out.println("唱红歌");
	}
	
	public void 泡妞() {              //可以重写
		System.out.println("唱红歌搞定fu女士");
	}
	
	public static void print() {
		System.out.println("Fu print");
	}
}

class Dayone extends 双桨 {
	public void 泡妞() {
		System.out.println("霸王硬上弓搞定fu女士");
	}
	
	public static void print() {         //静态只能覆盖静态，其实不算重写，多态时候会讲
		System.out.println("Zi print");
	}
}

四.override与overload的区别
overload可以改变返回值类型，只看参数列表
方法重写：子类中出现和父类中方法生命一样的方法，与返回值类型有关，返回值一致（或者是子父类）
方法重载：本类中出现的方法名一样，参数列表不同的方法，与返回值类型无关
子类对象调用方法的时候：先找子类本身，再找父类

八.final关键字特点

1.final概述

final是最终的

2.inal修饰特点

修饰类，类不能被继承
修饰变量，变量就变成了常量，只能被赋值一次
修饰方法，方法不能被重写

3.案例演示

public class Demo17_OOP_extends9_final {
	public static void main(String[] args) {
		Zi2 s = new Zi2();
		s.print();
	}
}

final class Fu2 {                            //修饰类，类中所有都不能被继承
	/*public final void print() {      //修饰方法，这个方法不能被重写
		System.out.println("访问底层数据资源");
	}*/
	public void print() {      //修饰方法，这个方法不能被重写
		System.out.println("访问底层数据资源");
	}
}

class Zi2 extends Fu2 {
	final int NUM = 10;					 //常量命名规范：如果是一个单词，所有字母大写，如果是多的单词
	                                     //，每个单词都大写，中间用下划线隔开
	public static final double PI = 3.14;//final修饰变量叫做常量，一般会与public static共用
	public void print() {
		//NUM = 20;               //强行赋值会出错
		System.out.println(NUM);  //10
		System.out.println("功能被重写了");
	}
}

4.final关键字修改局部变量

基本类型：值不能被改变
引用类型：地址值不能被改变，对象中的属性可以改变

5.案例演示

public class Demo17_OOP_extends9_final1 {
	public static void main(String[] args) {
		final int num = 10;//基本类型
		//num = 20;值不能被改变
		System.out.println(num);
		
		final person4 p = new person4("张三",23);//引用类型
		//p = new person4("李四",24);地址值不能被改变
		p.setName("李四");//改变属性
		p.setAge(24);
		System.out.println(p.getName() + "..." + p.getAge());
		
		//调用方法可以改变值，因为方法调用完后会弹栈
		method(10);   //10
		method(20);   //20
	}
	
	public static void method(final int x) {
		System.out.println(x);
	}
}

class person4 {
	private String name;
	private int age;
	
	public person4() {     //空参构造
	}
	
	public person4(String name,int age) {
		 this.name = name;
		 this.age = age;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
}

6.final修饰变量的初始化时机

显示初始化
在对象构造完毕前初始化

7.案例演示

public class Demo17_OOP_extends9_final2 {
	public static void main(String[] args) {
		Demo1 d = new Demo1();
		d.print();
	}
}

class Demo1 {
	//final int num = 10;//显示初始化
	final int num;       //在对象构造完毕前初始化
	
	public Demo1() {     //构造方法
		num = 10;
	}
	
	public void print() {
		System.out.println(num);
	}
}

九.多态(polymorphic)

一.什么是多态(polymorphic)

事物存在多种形态

二.多态前提

要有继承关系
要有方法重写
要有父类引用指向子类对象

案例演示

public class Demo17_OOP_extends11 {
	public static void main(String[] args) {
		cat1 c = new cat1();
		c.eat();//猫吃鱼
		
		Animal2 a = new cat1();//父类引用指向子类对象
		a.eat();//猫吃鱼
	}
}

class Animal2 {
	public void eat() {
		System.out.println("动物吃饭");
	}
}

class cat1 extends Animal2 {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

三.多态中的成员访问特点
1.成员变量
编译看左边(父类)，运行看左边(父类)
案例演示

public class Demo17_OOP_extends10_polymorphic2 {
	public static void main(String[] args) {
		father_a f = new son_a();
		System.out.println(f.num);//10
		
		son_a s = new son_a();
		System.out.println(s.num);//20
	}
}

class father_a {
	int num = 10;
}

class son_a extends father_a {
	int num = 20;
}

内存图

2.成员方法
编译看左边(父类)，运行看右边(子类),也叫作动态绑定
案例演示

public class Demo17_OOP_extends10_polymorphic2 {
	public static void main(String[] args) {
		father_a f = new son_a();
		f.print();//son
	}
}

class father_a {
    int num = 10;
	public void print() {
		System.out.println("father");
	}
}

class son_a extends father_a {
	int num = 20;
	public void print() {
		System.out.println("son");
	}
}

内存图

3.静态成员方法
编译看左边(父类)，运行看左边(父类)
(静态和类相关，算不上重写，所以访问还是左边)
案例演示

public class Demo17_OOP_extends10_polymorphic2 {
	public static void main(String[] args) {
		father_a f = new son_a();
		System.out.println(f.num);//10
		f.print();
		f.method();//相当于father_a.method
	}
}

class father_a {
	public static void method() {
		System.out.println("father static method");
	}
}

class son_a extends father_a {	
	public static void method() {
		System.out.println("son static method");
	}
}

总结

只有非静态的成员方法，编译看左边(父类)，运行看右边(子类)
成员变量与静态方法都是编译看左边(父类)，运行看左边(父类)

四.向上/下转型
1.父类引用指向子类对象就是向上转型
superman sm = (superman)p;向下转型

public class Demo17_OOP_extends10_polymorphic3 {
	public static void main(String[] args) {
		human p = new superman();//父类引用指向子类对象，超人提升为人
		                         //父类引用指向子类对象就是向上转型
		System.out.println(p.name);
		//p.fly();不能调用子类中的fly方法
		p.谈生意();
		superman sm = (superman)p;//向下转型
		sm.fly();//飞出去救人
	}
}

class human {
	String name = "John";
	
	public void 谈生意() {
		System.out.println("谈生意");
	}
}

class superman extends human {
	String name = "superman";
	
	public void 谈生意() {
		System.out.println("谈生意");
	}
	
	public void fly() {
		System.out.println("飞出去救人");
	}
}

五.多态的好处与弊端
1.多态的好处

提高了代码的维护性(继承实现)
提高了代码的扩展性

2.多态的弊端

不能使用子类的特有属性和行为
解决方法：向下转型

案例演示

可以当做形式参数，可以接收任意子类对象
关键字 instanceof 判断前面的引用是否是后面的数据类型

public class Demo17_OOP_extends10_polymorphic4 {
	public static void main(String[] args) {
		method(new cat2());
		method(new dog2());
	}
	
	public static void method(Animal3 a) {
		//关键字 instanceof 判断前面的引用是否是后面的数据类型
		if (a instanceof cat2) {
			cat2 c = (cat2)a;
			c.eat();//猫吃鱼
			c.catchmouse();//抓老鼠
		} else if (a instanceof dog2) {
			dog2 c = (dog2)a;
			c.eat();//狗吃肉
			c.lookhouse();//看家
		} else {
			a.eat();//动物吃饭
		}
	}
}

class Animal3 {
	public void eat() {
		System.out.println("动物吃饭");
	}
}

class cat2 extends Animal3 {
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void catchmouse() {
		System.out.println("抓老鼠");
	}
}

class dog2 extends Animal3 {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookhouse() {
		System.out.println("看家");
	}
}

六.抽象类(abstract)

1.抽象类概述

抽象就是看不懂的

2.抽象类特点

a:抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名 {}
public abstract void 方法名();

b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者接口
c:抽象类不能实例化(new 类名())，那么抽象类如何实例化呢?

按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态

d:抽象类的子类

要么是抽象类
要么重写抽象类中的所有抽象方法

案例分析

public class Demo17_OOP_extends10_polymorphic5_Abstract1 {
	public static void main(String[] args) {
		//Animal4 a = new Animal();         //错误：Animal是抽象的 无法实例化(new Animal)
		Animal4 a = new cat3();
		a.eat();//猫吃鱼
	}
}

abstract class Animal4 {//抽象类
	public abstract void eat();//有抽象方法的类一定是抽象类或者接口
}

class cat3 extends Animal4 {//重写
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

3.抽象类的成员特点

a:成员变量：既可以是变量，也可以是常量

abstract是否可以修饰成员变量？
不能修饰成员变量

b:构造方法

用于子类访问父类数据的初始化

c:成员方法：既可以是抽象的，也可以是非抽象的

4.抽象类的成员方法特性

抽象方法强制要求子类做的事情
非抽象方法子类继承的事情，提高代码的复用性

案例演示

public class Demo17_OOP_extends10_polymorphic5_Abstract2 {
	public static void main(String[] args) {
		DemoFu d = new TestZi();
		d.method();
	}
}

abstract class DemoFu {
	int num1 = 10;//变量
	final int num2 = 20;//常量
	
	public DemoFu() {}//构造方法
	
	public void print() {//非抽象方法
		System.out.println("111");
	}
	
	public abstract void method();//抽象方法
}

class TestZi extends DemoFu {
	public void method() {//重写
		System.out.println("111");
	}
}

5.abstract关键字的注意事项

 一个抽象类如果没有抽象对象，可不可以定义为抽象类？如果可以，有什么意义？

可以，这么做的目的只有一个：就是不让其它类创建本类对象，交给子类完成

abstract不能和哪些关键字共存？

abstract和static

被abstract修饰的方法没有方法体
被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的

abstract和final

被abstract修饰的方法强制子类重写
被final修饰的不让子类重写，所以他俩是矛盾的

abstract和private

被abstract修饰的方法是为了让子类看到并强制重写
被private修饰的方法不让子类访问，所以他俩是矛盾的

案例演示

class 关键字 {
	//public static abstract void print();     //错误：非法的修饰符组合：abstract和static
	//public final abstract void print();      //错误：非法的修饰符组合：abstract和final
	//private abstract void print();           //错误：非法的修饰符组合：abstract和private
}

七.接口

1.接口概述

从狭义的角度讲就是指java中的interface
从广义的角度讲就是对外提供规则的都是接口

2.接口特点

a:接口用关键字interface表示

interface 接口名 {}

b:类实现接口用implements 接口名 {}

class 类名 implements 接口名 {}

c:接口不能实例化

那么接口如何实例化呢？
按照多态的方式来实例化

d:接口的子类

可以是抽象类。但意义不大
可以是具体类。要重写接口中的所有抽象方法

案例演示

public class Demo17_OOP_extends10_polymorphic6_interface1 {
	public static void main(String[] args) {
		//Inter i = new Inter();     //接口不能被实例化，因为调用抽象方法没有意义
		Inter i = new Demb();        //父类引用指向子类对象
		i.print();
	}
}

interface Inter {
	public abstract void print();
}

class Demb implements Inter {
	public void print() {
		System.out.print("print");
	}
}

3.接口的成员特点

成员变量：只能是常量，并且是静态的并公开的

 默认修饰符：public static final、
 建议：自己手动给出

构造方法：接口没有构造方法

成员方法：只能是抽象方法

    *默认修饰符：public abstract
    *建议：自己手动给出

案例演示

public class Demo17_OOP_extends10_polymorphic6_interface2 {
	public static void main(String[] args) {
		Demb1 d = new Demb1();
		d.print();//10
		System.out.println(Inter1.num);//10
	}
}

interface Inter1 {
	public static final int num = 10;//接口中默认加public static final三者位置可互换
	
	//public Inter1() {}  //接口中没有构造方法
	
	//public void print() {}      //接口中不能定义非抽象方法
	
	public abstract void print();//public abstract可省略
}

class Demb1 extends Object implements Inter1 {//一个类不写继承任何类，默认继承Object类,可省略extends Object
	public void print() {
		//num = 20;不能改变接口中变量的值
		System.out.println(num);
	}
	
	public Demb1() {
		super();
	}
}

4.类与类，类与接口，接口与接口的关系

a:类与类

继承关系：只能单继承，可以多层继承

b:类与接口

实现关系：可以单实现，也可以多实现
并且还可以在继承一个类的同时实现多个接口

c:接口与接口

继承关系: 可以单继承，也可以多继承

public class Demo17_OOP_extends10_polymorphic6_interface3 {
	public static void main(String[] args) {
		
	}
}

interface InterA {
	public abstract void printA();
}

interface InterB {
	public abstract void printB();
}

interface InterC extends InterA,InterB {//继承
	
}

//class Demc implements InterA,implements InterB {}这么做不允许是非法的

class Demc implements InterA,InterB {//实现
	public abstract void printA() {
		System.out.print("printA");
	}
	
	public abstract void printB() {
		System.out.print("printB");
	}
}

补充：

抽象类与接口类的设计理念区别
抽象类被继承体现的是："is a"的关系。抽象类定义的是被继承体系的共性功能
接口被实现体现的是："like a"的关系。接口中定义的是被继承体系扩展功能

wo不理智

关注

1
点赞
踩
1

收藏

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

代码块1.普通代码块：类中方法的方法体（限定了变量的生命周期，出大括号就释放内存）2.构造代码块：构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。3.静态代码块：用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于构造代码块执行。4.同步代码块：使用synchronized（）{}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。同步代码块需要写在方法中。二.静态代码块和构造代码块的异同点相同点：都是
复制链接

扫一扫