7.JAVA面向对象之继承_java 面向对象之继承-CSDN博客

本文链接：https://blog.csdn.net/weixin_56027329/article/details/129962125

一、继承(关键字extends)

1.1概述

继承是面向对象最显著的一个特性。

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。

这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

提高复用性：只要继承父类，就能有一样的功能

1.2特点

1、使用extends关键字

2、相当于子类把父类的功能复制了一份

3、 java只支持单继承

4、继承可以传递（爷爷，儿子，孙子的关系）

5、不能继承父类的私有成员

6、继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展

7、像是is a 的关系

1.3练习

package cn.tedu.oop;
//测试继承
public class Test5 {
	public static void main(String[] args) {
		new zi().eat();
		new zi().sleep();
//		new zi().money = 89;//继承这样写无效，无法更改父类的值
		System.out.println(new zi().money);
		sunzi sz = new sunzi();//继承的传递性
		sz.eat();
		sz.sleep();
		System.out.println(sz.money);
	}
}
class fu{//同一包里不可有相同名字，否则报错
	double money = 85;
	public void eat() {
		System.out.println("吃肉");
	}
	public void sleep() {
		System.out.println("睡觉觉");
	}
}
class zi extends fu{
	//子类把父类的功能复制一份
}
class sunzi extends zi{   }

二、super关键字

2.1概述

1、在子类中用，用来调用父类的功能

2、 super代表父类的一个引用对象

3、和this一样，出现在构造方法里，必须出现在第一行

三、方法重写(Override)

3.1概述

1、继承后，子类就拥有了父类的功能，发生在父子类里的关系。

2、那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能(修改就要重写)

3、子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能

注意：

1、父类中的私有方法不能被重写

2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

3.2练习

3.2.1成员变量的使用

package cn.tedu.oop;
// --测试继承里的成员变量的使用
public class Test1 {
	public static void main(String[] args) {
		zi z = new zi();
		z.show();
	}
}
class fu{
	String name = "白小纯";
	public void eat() {
		System.out.println("吃饭饭");
	}
	public void sport() {
		System.out.println("跑步步");
	}
}
class zi extends fu{
	String name = "王林";
	int age = 20;
	public void show() {
		int age = 10;
		System.out.println(age);//就近原则
		System.out.println(this.age);//调用本类的成员变量
		System.out.println(name);
		System.out.println(super.name);//使用父类资源
	}
}

3.2.2继承里的方法使用

package cn.tedu.oop;
//测试 继承里的方法
public class Test2 {
	public static void main(String[] args) {
		zi1 z = new zi1();
		z.eat();
		z.show();
		z.study();
		new fu1().show();//遵循OCP原则
	}
}
class fu1{
	public void show() {
		System.out.println("访谈节目");
	}
	public void eat() {
		System.out.println("吃东西");
	}
}
class zi1 extends fu1{
	public void study() {
		System.out.println("学习历史");
	}
	public void show() {
		System.out.println("访谈节目2");
	}
}

3.2.3继承里的构造方法使用(构造方法不能被继承)

package cn.tedu.oop;
//测试继承里的构造方法
public class Test3 {
	public static void main(String[] args) {
		new zi2(); 
		new zi2(2); 
		
	}

}
class fu2{
	public fu2() {
		System.out.println(1);
	}
	public fu2(int age) {
		System.out.println("年龄");
	}
	public fu2(String name) {
		System.out.println("名字");
	}
}
class zi2 extends fu2{
	//在2前面先输出1，因为隐藏super(),会自动调用父类的无参构造方法
	public zi2() {
//		super();//必须放在方法里,会自动调用父类的无参构造方法
		super(2);//触发父类的含参构造方法
		System.out.println(2);
	}
	public zi2(int ID) {
		System.out.println("学号");
	}
	public zi2(char sex) {
		System.out.println("性别");
	}
}

3.3拓展

3.3.1this和super的区别

1、 this代表本类对象的引用，super代表父类对象的引用。

2、 this用于区分局部变量和成员变量

3、 super用于区分本类变量和父类变量

4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容

5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容

6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行。

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

1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同

2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型

3、重写是父类与子类之间多态性的一种表现

4、重载是一类中多态性的一种表现，体现出程序的灵活性。

四、static(静态)

4.1概述

1、是java中的一个关键字

2、用于修饰成员（成员变量和成员方法）

4.2特点

1、可以修饰成员变量，成员方法

2、随着类的加载而加载，优先于对象加载

3、只加载一次，就会一直存在，不再开辟新空间

4、全局唯一，全局共享

5、 可以直接被类名调用，普通资源不可类名调用

6、静态只能调用静态，非静态可以随意调用

7、 static不能和this或者super共用，因为有static时可能还没有对象

package cn.tedu.oop;
//测试  static  关键字
public class Test5 {
	public static void main(String[] args) {
		Person p = new Person();
		System.out.println(p.age);
		p.eat();
		p.sleep();
		System.out.println(p.name);
		Person.sleep();//static可以直接通过类名访问
		System.out.println(Person.name);
		Person p1 = new Person();
		p1.name = "白熊爱吃";
		Person p2 = new Person();
		System.out.println(p2.name);
		Person p3 = new Person();
		System.out.println(p3.name);
	}
}
class Person{
	int age = 45;
	public void eat() {
		System.out.println(1);
		System.out.println(name);//普通资源随意调用静态资源
	}
	//static 可以修饰成员变量和方法
	//优先于对象加载
	//资源是共享的，可以直接被类名调用
	static String name="王林";
	public static void sleep() {
		System.out.println(1);
		System.out.println(name);
//		System.out.println(age);//静态资源不能调用普通资源
	}
}

五、静态代码块

5.1概述

随着类的加载而加载，并且只被加载一次，一般用于项目的初始化 static{…}

1、静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化，在成员位置。

2、构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用

3、局部代码块：方法里的代码块，方法被调用时才会执行

4、静态代码块：static{ }，位置：在类里方法外

5、优先级：静态代码块 - 构造代码块 - 构造方法 - 局部代码块

package cn.tedu.oop;
//测试  static 代码块
public class Test6 {
	public static void main(String[] args) {
//		Class.forName("cn.tedu.oop.Student");
		new Student().show();
	}
}
class Student{
	static {
		System.out.println("静态代码块");//类里方法外
	}
	public Student() {
		System.out.println("构造方法");
	}
	{
		System.out.println("构造代码块");//类里方法外
	}
	public void show() {
		{
			System.out.println("局部代码块");//方法里
		}		
	}
}

六、final关键字

6.1概述

1、 final是最终的意思

2、 final可以修饰类，方法，成员变量

3、用来约束父类资源的重写权限

6.2特点

1、被final修饰的类，不能被继承

2、被final修饰的方法，不能被重写

3、被final修饰的变量是个常量，值不能被更改

4、常量的定义形式： final 数据类型常量名 = 值

package cn.tedu.oop;
//测试  final  关键字
public class Test7 {
	public static void main(String[] args) {
		zi123 z = new zi123();
		z.eat();
//		z.age = 56;
		System.out.println(z.age);
	}

}
class fu123{//前面加final。该类不能被继承
	final int age = 23;
	public final void eat() {
		System.out.println("麻婆豆腐");
	}
}
class zi123 extends fu123{
//	public  void eat() {
//		System.out.println("吃东子aaaaa");//不能重写,因为被final私有,可以继承
//	}
}