JavaSE继承
一、继承
- 理解继承
Cat继承了Animal类，其中：Animal类称为父类/基类或超类，Cat可以称为Animal的
子类/派生类，继承之后， 子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可Java中不支持多继承，仅支持A extends B 单继承//A extends B B extends C 多层继承 //A extends C B extends C 不同类继承自同一类。
public class TestExtend {
public static void main(String[] args) {
Dog d1 =new Dog();
d1.name = "xiaocs";
d1.age = 15;
Cat c1 = new Cat();
c1.color = "red";
c1.type = "波斯";
c1.friendly();
}
}
/**
* Dog未继承animal则无法调用animal中的成员变量和成员方法
*/
class Dog{
public int age;
public String name;
public void shot(){
System.out.println("汪汪汪");
}
}
//cat可以直接调用animal中的成员变量和成员方法
class Cat extends animal{
public int weight;
public String sex;
public void eat(){
System.out.println("嘎嘎吃");
}
}
class animal{
public String color;
public String type;
public void friendly(){
System.out.println("对人类友好");
}
}子类访问父类
子类和父类不存在同名成员变量
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 }子类和父类成员变量同名
public class Base { int a; int b; int c; } public class Derived extends Base{ int a; // 与父类中成员a同名，且类型相同 char b; // 与父类中成员b同名，但类型不同 public void method(){ a = 100; b = 101; c = 102; // 子类没有c，访问的肯定是从父类继承下来的c // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b } }- 成员变量访问遵循就近原则，自己有优先自己的，与父类同名也优先访问自己的，如果没有则向父类中找。
- 成员方法亦然，如果子类有则先访问子类的，子类没有先访问父类的，如果存在方法重载，则根据引用的情况，选择合适的方法
- 在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可
二、super关键字
- 当父类和子类的成员变量或成员方法相同时，调用父类的成员变量或方法，使用super关键字
class Cat extends animal{
public int color;
public String type;
public void eat(){
//调用父类的成员变量
super.color = "red";
super.type = "波斯";
super.friendly();
System.out.println("嘎嘎吃");
}
}
class animal{
public String color;
public String type;
public void friendly(){
System.out.println("对人类友好");
}
}
- 子类的构造方法(无参数)
- 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
public class TestExtend {
public static void main(String[] args) {
Cat c = new Cat();
}
}
class Cat extends animal{
public int size;
public String name;
public Cat(){
// super();
//注意子类构造方法中默认会调用基类的无参构造方法：super(),
// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
// 并且只能出现一次
System.out.println("Cat::");
}
public void eat(){
System.out.println("嘎嘎吃");
}
}
class animal{
public String color;
public String type;
public animal() {
System.out.println("animal::");
}
public void friendly(){
System.out.println("对人类友好");
}
}
子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法。
- 子类的构造方法(有参数)
- 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则会编译失败
/**
* Created with IntelliJ IDEA.
* Description:
* User: snutyx
* Date: 2022-08-30
* Time: 17:05
*/
public class TestExtend {
public static void main(String[] args) {
Cat c = new Cat("red","波斯",45,"xiaos");
}
}
class Cat extends animal{
public int size;
public String name;
public Cat(String color, String type, int size, String name) {
super(color, type);
this.size = size;
this.name = name;
}
public void eat(){
System.out.println("嘎嘎吃");
}
}
class animal{
public String color;
public String type;
public animal(String color, String type) {
this.color = color;
this.type = type;
}
public void friendly(){
System.out.println("对人类友好");
}
}
- 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
- super(...)只能在子类构造方法中出现一次，并且不能和this同时出现
✅super和this之间的区别？
- 相同点：
1.都属于java 中 的关键字
2.只能在类的非静态方法中使用，用来访问 非静态的方法和字段
3.在构造 方法中使用时必须是构造方法当中的第一条语句，并且二者不能同时存在
- 不同点：
1.this指的是当前对象的引用，super指的是当前对象对父类部分对象的使用
- 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
- 在构造方法当中，this用于调用本类的构造方法，super调用父类的构造方法，两种调用不能同时在构造方法中出现
- 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有
三、继承关系下的代码块
public class TestExtend {
public static void main(String[] args) {
Cat c = new Cat("red","波斯",45,"xiaos");
}
}
class Cat extends animal{
public int size;
public String name;
//5.子类的实例代码块
{
System.out.println("cat::实例");
}
//2.子类的静态代码块
static{
System.out.println("cat::static");
}
//6.子类的构造方法
public Cat(String color, String type, int size, String name) {
super(color, type);
this.size = size;
this.name = name;
System.out.println("cat::构造");
}
public void eat(){
System.out.println("嘎嘎吃");
}
}
class animal{
public String color;
public String type;
//3.父类的实例代码块
{
System.out.println("animal::实例");
}
//1。父类的静态代码块
static{
System.out.println("animal::static");
}
//4.父类的构造方法
public animal(String color, String type) {
this.color = color;
this.type = type;
System.out.println("animal::构造");
}
public void friendly(){
System.out.println("对人类友好");
}
根据执行结果可以的出以下结论：
父类的静态代码块>>子类的静态代码块>>父类的实例代码块>父类的构造方法>>子类的实例代码块>> 子类的构造方法
- 第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
四、protected关键字
访问限定：同一个包中的类和不同包中的子类
package TestDemo2;
public class B {
private int a;
protected int b;
public int c;
int d;
}在不同包中即package TestDemo 中
只有public和protected修饰的成员可以访问
五、final关键字
- 修饰变量时： 表示常量即不能修改
final int a = 10;
a = 20; // 编译出错- 修饰类时： 表示此类不能被继承，即不能作为父类
//final修饰
final class animal{
public String color;
public String type;
public animal(String color, String type) {
this.color = color;
this.type = type;
System.out.println("animal::构造");
}
}
