JavaSE语法之八:继承(超全!!)
文章目录
一、继承的概念
Java中使用类对现实世界中实体来进行描述,类经过实例化之后的产物对象,则可以用来表示现实中的实体,现实世界错误复杂,事物之间可能会存在一些联系,比如:狗和猫,它们都是一个动物。
按我们之前学到,猫和狗有一些相同的动物属性,代码写起来就比较冗余,所以引出继承。
继承(inheritance)机制:是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。
继承最大的意义:对代码可以进行复用。
子类 extends 父类:is-a 的关系
二、继承的语法
修饰符 class 子类 extends 父类 {
// …
}
// Animal.java
public class Animal{
String name;
int age;
public void eat(){
System.out.println(name + "正在吃饭");
}
public void sleep(){
System.out.println(name + "正在睡觉");
}
}
// Dog.java
public class Dog extends Animal{
void bark(){
System.out.println(name + "汪汪汪~~~");
}
// Cat.Java
public class Cat extends Animal{
void mew(){
System.out.println(name + "喵喵喵~~~");
}
}
// TestExtend.java
public class TestExtend {
public static void main(String[] args) {
Dog dog = new Dog();
// dog类中并没有定义任何成员变量,name和age属 性肯定是从父类Animal中继承下来的
System.out.println(dog.name);
System.out.println(dog.age);
// dog访问的eat()和sleep()方法也是从Animal中继承下来的
dog.eat();
dog.sleep();
dog.bark();
}
}
注意:
- 子类会将父类中的成员变量或者成员方法继承到子类中;
- 子类继承父类之后,必须要新添加自己特有的成员,体现出与基类的不同,否则就没有必要继承了。
三、父类成员访问
1.子类中访问父类的成员变量
(1)子类和父类不存在同名成员变量
子类又有,就拿子类的;子类没有,就拿父类的。
//父类
public class Base {
int a;
int b;
}
//子类
public class Derived extends Base{
int c;
public void method(){
a = 10; // 访问从父类中继承下来的a
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c
}
}
(2)子类和父类成员变量同名
如果父类和子类有重名的成员变量,优先使用子类的(就近原则)。
//父类
public class Base {
int a = 1;
int b = 2;
int c = 3;
}
//子类
public class Derived extends Base{
int a; // 与父类中成员a同名,且类型相同
char b; // 与父类中成员b同名,但类型不同
public void method(){
a = 100; // 访问子类自己新增的a
b = 101; // 访问子类自己新增的b
c = 102; // 子类没有c,访问的肯定是从父类继承下来的c
// d = 103; // 编译失败,因为父类和子类都没有定义成员变量b
super.a; //是超类,暂且理解为引用的父类(就想访问父类)
}
}
在子类方法中 或者 通过子类对象访问成员时:
- 如果访问的成员变量子类中有,优先访问自己的成员变量;
- 如果访问的成员变量子类中无,则访问父类继承下来的,如果父类中也没有定义,则编译报错;
- 如果访问的成员变量与父类中成员变量同名,则优先访问自己的。
成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找。
1.子类中访问父类的成员方法
在成员方法名不同时,在子类方法中或者通过子类对象访问方法时:
①优先访问自己的;
②如果自己没有,再到父类找;
③如果父类中也没有,则报错。
(1)成员方法名字不同
//父类
public class Base {
public void methodA(){
System.out.println("Base中的methodA()");
}
}
//子类
public class Derived extends Base{
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
methodB(); // 访问子类自己的methodB()
methodA(); // 访问父类继承的methodA()
// methodD(); // 编译失败,在整个继承体系中没有发现方法methodD()
}
}
(2)成员方法名字相同
通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法传递参数选择合适的方法访问,如果没有则报错;
//父类
public class Base {
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
//子类
public class Derived extends Base{
public void methodA(int a) {
System.out.println("Derived中的method(int)方法");
}
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
methodA(); // 没有传参,访问父类中的methodA()
methodA(20); // 传递int参数,访问子类中的methodA(int)
methodB(); // 直接访问,则永远访问到的都是子类中的methodB(),基类的无法访问到
super.methodB(); //访问父类的methodB()方法
}
}
四、super 关键字
主要作用:在子类方法中访问父类的成员。
super只是一个关键字,最大的作用其实是在你写代码或者读代码的时候,体现出更好的可读性!
【注意事项】:
- 只能在非静态方法中使用;
- 在子类方法中,访问父类的成员变量和方法;
- 只能指代直接的父类,不能访问爷爷类。
五、子类构造方法
父子父子,先有父再有子。
即:子类对象构造时,需要先调用基类构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整。
//父类/基类
public class Base {
public Base(){
System.out.println("Base()");
}
}
//子类
public class Derived extends Base{
public Derived(){
// super(); // 注意子类构造方法中默认会调用基类的无参构造方法:super(),
// 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句,
// 并且只能出现一次
System.out.println("Derived()");
}
}
public class Test {
public static void main(String[] args) {
Derived d = new Derived();
}
}
执行结果:
Base()
Derived()
在继承关系上,我们什么构造方法都没写的时候,编译器会有默认的以下两个构造方法:
//父类
public Animal() {
}
//子类
public Dog() {
super();
}
其中,关于super:
① 注意子类构造方法中默认会调用基类的无参构造方法:super();
② 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句;
③ super只能出现一次,且不能和this同时出现。
【注意】
① 若父类显示定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用基类构造方法;
② 如果父类构造方法是带参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的父类构造方法调用,否则编译失败;
六、super 和 this
在调用构造方法的时候,不能同时出现!
【相同点】
- 都是Java中的关键字;
- 只能在类的非静态方法中使用,用来访问非静态成员方法和字段;
- 在构造方法中调用时,必须是 构造方法中的第一条语句,并且不能同时存在。
【不同点】
- this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象从父类继承下来部分成员的引用;
- 在非静态成员方法中,this用来访问本类的方法和属性,super用来访问父类继承下来的方法和属性;
- 在构造方法中,this(…) 用来调用本类构造方法,super(…) 用于调用父类构造方法,两种调用不能同时在构造方法中出现;
- 构造方法中一定会存在super(…)
七、初始化
之前我们学的实例代码块和静态代码块,在没有继承关系时的执行顺序。
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("构造方法执行");
}
{
System.out.println("实例代码块执行");
}
static {
System.out.println("静态代码块执行");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person1 = new Person("张三",10);
System.out.println("============================");
Person person2 = new Person("李四",20);
}
}
执行结果:
静态代码块执行
实例代码块执行
构造方法执行
====================
实例代码块执行
构造方法执行
- 静态代码块先执行,并且执行一次,在类加载阶段执行;
- 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行。
【继承关系上的执行顺序】
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person:构造方法执行");
}
{
System.out.println("Person:实例代码块执行");
}
static {
System.out.println("Person:静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age) {
super(name,age);
System.out.println("Student:构造方法执行");
}
{
System.out.println("Student:实例代码块执行");
}
static {
System.out.println("Student:静态代码块执行");
}
}
public class TestDemo4 {
public static void main(String[] args) {
Student student1 = new Student("张三",19);
System.out.println("===========================");
Student student2 = new Student("gaobo",20);
}
//执行结果
Person:静态代码块执行
Student:静态代码块执行
Person:实例代码块执行
Person:构造方法执行
Student:实例代码块执行
Student:构造方法执行
===========================
Person:实例代码块执行
Person:构造方法执行
Student:实例代码块执行
Student:构造方法执行
通过分析执行结果,得出以下结论:
① 父类静态代码块优先于子类静态代码块执行,且是最早执行;
②父类实例代码块和父类构造方法紧接着执行;
③ 子类的实例代码块和子类构造方法紧接着再执行;
④第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行。
父类优先于子类执行,静态的最先执行。
八、protected关键字
在类和对象中,为了实现封装特性,Java中引入了访问限定符,主要限定:类或者类中成员能否在类外或者其他包中被访问。
受保护的,继承上
1. 同类
package demo1;
public class TestDemo1 {
protected int a = 99;
public static void main(String[] args) {
TestDemo1 testDemo1 = new TestDemo1();
System.out.println(testDemo1.a);
}
}
2. 同包不同类
package demo1;
public class TestDemo1 {
protected int a = 99;
}
package demo1;
public class TestDemo2 {
public static void main(String[] args) {
TestDemo1 testDemo1 = new TestDemo1();
System.out.println("不同类" + testDemo1.a);
}
}
3. 不同包的子类
在不同包的继承子类中,注意:
① 不能直接在main方法中引用,因为他是受保护的,所以要使用super发来访问;
② 新建一个方法写super,因为静态方法中不能用super。
package demo1;
public class TestDemo1 {
protected int a = 99;
private int b;
}
package demo2;
import demo1.TestDemo1;
public class TestDemo3 extends TestDemo1 {
public void func() {
//再写一个方法放super,不直接写道main方法中,是因为main方法是静态方法,静态方法中不能放super
System.out.println(super.a);
// System.out.println(super.b); //编译报错,父类private成员再相同包子类中不可见
}
public static void main(String[] args) {
TestDemo3 testDemo3 = new TestDemo3();
testDemo3.func();
}
}
其中:类必须都是public
注意:父类中private成员变量虽然在子类中不能直接访问,但是也继承到子类中了。
什么时候下用哪一种呢?
我们希望类要尽量做到“封装”,即隐藏内部实现细节,只需暴露出必要的信息给类的调用者。
因此我们在使用的时候,应尽可能的使用比较严格的访问权限。例如,如果一个方法能用private,就尽量不要用public。
另外还有一种粗暴的做法:将所有的字段设为 private,将所有的方法设为 public。 不过这种方式属于是对访问权限的滥用,我们在写代码的时候,还是要认真思考该类提供的字段方法到底给“谁”使用(是类内部自己用,还是类的调用者使用,还是子类使用)
九、继承方式
【单继承】
public class A {
……
}
public class B extends A {
……
}
【多层继承】
public class A {……}
public class B extends A {……}
public class C extends B {……}
【不同类继承同一个类】
public class A {……}
public class B extends A {……}
public class C extends A {……}
【多继承】(不支持)
public class A {……}
public class B {……}
public class C extends A , B {……} //错误,Java不支持多继承
注意:Java中不支持多继承。
一般我们不希望出现超过三层的继承关系,如果继承层次太多,就需要考虑对代码进行重构了。
如果想从语法上进行限制继承,就可以使用final关键字。
十、final关键字
final关键字可以用来修饰变量、成员方法以及类。
1. 修饰变量或字段,表示常量(即不能修改)
一般常量名要大写。
final int A = 10;
A = 20; // 编译出错
如果是成员变量定义为final,语法规定必须要给一个初始值。
class Animal {
public final String name = "123";
}
关于数组:
final int[] array = {1,2,3};
array = new int[10]; //报错
array[0] = 19; //正确
被final修饰的array这个引用指向的对象是不能改变的,但是可以改变里面的值。
2. 修饰类:表示此类不能被继承
final public class Animal {
...
}
public class Bird extends Animal {
...
}
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继
我们平时使用的String字符串类,就是final修饰,不能被继承。
3. 修饰方法:表示该方法不能被重写
十一、继承与组合
组合:是一种代码的实现方式,设计思想。
面向对象的三大特性:封装、继承、多态。
继承表示对象之间是 is - a 的关系,如:狗是动物,猫是动物
组合表示对象之间是 has - a 的关系,如:汽车和轮胎、发动机、方向盘等的关系就是组合,因为汽车是由这些不见组成的。
在一个类里面,会将另一个类当作这个类的属性,用的比较多!
// 学生类
class Student{
}
// 教师类
class Teacher{
}
//教学楼类
class House{
}
// 学校类
class School{
public Student[] students = new Student[3];// 可以复用学生中的属性和方法
public Teacher[] teachers = new Teacher[3];// 可以复用教师中的属性和方法
}
// 一中是学校
class YiZhong extend School{
// 将学校中包含的:学生、教师全部继承下来
}
public class Test {
public static void main(String[] args) {
School school = new School();
}
}
在一个类里面,会将另一个类作为我当前类的属性,这个设计思想就是组合,也相当于是代码的复用。我们日常用的比较多,如:接口、循序表等都有组合的思想在其中。
其中上述代码中,main函数中的内存情况如图所示:
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!