详解"/>
初始java( 4 )7000字详解
一:继承
1.1 继承的引入
首先我们来说说为什么要有继承,继承在生活中的体现是什么
我们知道每个人都会有DNA,DNA中有许多基因,我们中有许多基因都是从父亲母亲那继承过来的,当然,我们还会继承父母的财产,性格,为人处世等等等等
在java中同样也存在继承,java中的继承的目的主要是用于共性提取,代码复用,减少代码的重复性
下面通过一个例子来说明:
Dog类:
public class Dog{string name;int age;float weight;public void eat(){System.out.println(name + "正在吃饭");}public void sleep(){System.out.println(name + "正在睡觉");}void Bark(){System.out.println(name + "汪汪汪~~~");}
}
Cat类:
public class Cat{string name;int age;float weight;public void eat(){System.out.println(name + "正在吃饭");}public void sleep(){System.out.println(name + "正在睡觉");}void mew(){System.out.println(name + "喵喵喵~~~");}
}
通过比较会发现,猫和狗类中存在着大量的重复,如图所示:
为了将这些共性提取出来,java提出了继承的概念,专门用来进行共性提取,实现代码的复用
1.2继承的概念
继承:是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特 性的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。
例如:狗和猫都是动物,那么我们就可以将共性的内容进行抽取,然后采用继承的思想来达到共用。
上述图示中,Dog和Cat都继承了Animal类,其中:Animal类称为父类/基类或超类,Dog和Cat可以称为Animal的子类/派生类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可。
1.3 继承的语法
在Java中如果要表示类之间的继承关系,需要借助extends关键字,具体如下:
修饰符 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();}
}
注意:在java中只支持单继承,并不支持多继承
下面是我对继承的理解:
1.4父类成员和子类成员冲突问题
通过子类对象访问成员时:
- 如果访问的成员变量子类中有,优先访问自己的成员变量。
- 如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。
- 如果访问的成员变量与父类中成员变量同名,则优先访问自己的。
成员变量访问遵循就近原则,自己有优先用自己的,如果没有则向父类中找。
下面是个简单的代码示例:
class Parent {int num = 10;
}class Child extends Parent {int num = 20;void display() {System.out.println( num); // 访问自己的成员变量}
}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}
}
输出结果是: 20
```java
class Parent {int num = 10;
}class Child extends Parent {void display() {System.out.println( num); // 访问自己的成员变量}
}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}
}
输出结果是: 10
class Parent {
}class Child extends Parent {int num = 20;void display() {System.out.println( num); // 访问自己的成员变量}
}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}
}
输出结果是: 20
同理,子类中如果存在和父类同名的方法,那么也是遵循这个原则,子类有就访问自己的,没有再去父类中找
1.5 super关键字
但是当子类和父类的变量或者方法重名了,我们又确实想访问父类的变量或者方法,那么该怎么办呢?
我们直接访问是无法做到的,但是java为我们提供了super关键字,该关键字主要作用:在子类方法中访问父类的成员。和this类似,super也有三种作用:
-
super.成员变量
-
super.方法名()
-
super()
下面通过一个简单的代码例子来说明super的作用:
当在子类中使用super
关键字时,有三种常见的用法:
super.成员变量
:用于访问父类中的成员变量。
class Animal {String name = "Animal类的成员变量";
}class Dog extends Animal {String name = "Dog类的成员变量";void printName() {System.out.println(super.name); // 访问父类的成员变量}
}public class Main {public static void main(String[] args) {Dog dog = new Dog();dog.printName(); // 输出:Animal类的成员变量}
}
super.方法名()
:用于在子类中调用父类中的方法。
class Animal {void print() {System.out.println("Animal类的方法");}
}class Dog extends Animal {void print() {super.print(); // 调用父类的方法System.out.println("Dog类的方法");}
}public class Main {public static void main(String[] args) {Dog dog = new Dog();dog.print(); // 输出:Animal类的方法 // Dog类的方法}
}
super()
:用于在子类的构造方法中调用父类的构造方法。
class Animal {String name;Animal(String n) {name = n;}void printName() {System.out.println(name);}
}class Dog extends Animal {Dog(String n) {super(n); // 调用父类的构造方法}
}public class Main {public static void main(String[] args) {Dog dog = new Dog("Dog对象");dog.printName(); // 输出:Dog对象}
}
在子类方法中,如果想要明确访问父类中成员时,借助super关键字即可。
注意事项:
- super和this都只能在非静态方法中使用
1.6 子类的构造方法与父类的构造方法
父子父子,有父才有子
java规定,在子类的构造方法中,要通过super()调用父类的构造方法,先帮从父类继承过来的变量进行构造,再构造自己的变量,通过调用父类构造方法和子类构造方法后,就可以对一个类中的所有的变量进行初始化了
子类对象中成员是有两部分组成的,父类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从父类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 。
注意:
- 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用父类构造方法
- 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的
父类构造方法调用,否则编译失败。 - 在子类构造方法中,super(…)调用父类构造时,必须是子类构造函数中第一条语句。
- super(…)只能在子类构造方法中出现一次,并且不能和this同时出现(super和this都要放第一行,这就矛盾了)
下面是一个示例代码,演示了子类构造方法显式调用父类构造方法的情况:
class Parent {private int age;public Parent(int age) {this.age = age;}public int getAge() {return age;}
}class Child extends Parent {private String name;public Child(String name, int age) {super(age); // 调用父类的构造方法进行年龄的初始化this.name = name;}public String getName() {return name;}
}public class Main {public static void main(String[] args) {Child child = new Child("Alice", 10);System.out.println("Name: " + child.getName());System.out.println("Age: " + child.getAge());}
}
在上述示例中,父类Parent
定义了一个有参构造方法来初始化age
属性。子类Child
的构造方法使用super(age)
显式地调用了父类的构造方法来初始化父类的age
属性。通过这种方式,子类可以在构造对象时进行对父类属性的初始化操作。
1.7再谈代码块
1.7.1 无继承关系上的执行顺序:
我们还记得之前讲过的代码块吗?我们简单回顾一下几个重要的代码块:实例代码块和静态代码块。在没有继承关系时的执行顺序。
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("bit",10);System.out.println(" ");Person person2 = new Person("gaobo",20);}
}
执行结果:
静态代码块执行
实例代码块执行
构造方法执行
实例代码块执行
构造方法执行
1.7.2继承关系上的执行顺序:
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);}public static void main1(String[] args) {Person person1 = new Person("bit",10);System.out.println("============================");Person person2 = new Person("gaobo",20);}
}
执行结果:
通过分析执行结果,得出以下结论:
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行
1.8继承关系视图
二:final关键字
在Java中,final
关键字可以用来修饰变量、方法和类。它的作用如下:
- 修饰变量:当
final
关键字修饰一个变量时,表示该变量的值只能被赋值一次,赋值后不可再改变。一般将final
修饰的变量称为常量,通常使用大写字母表示。常量的值在程序运行期间保持不变。
示例代码:
final int age = 18;
// age = 20; // 编译错误,不能再次赋值给常量age
System.out.println(age); // 输出结果:18
- 修饰方法:当
final
关键字修饰一个方法时,表示该方法不能被子类重写。这样可以确保方法的实现不会被修改,保持方法的稳定性。(这里了解即可,后面会讲什么是重写)
示例代码:
public class SuperClass {public final void printMessage() {System.out.println("This is a final method.");}
}public class SubClass extends SuperClass {// 尝试重写final方法,编译错误// public void printMessage() { }public static void main(String[] args) {SubClass sub = new SubClass();sub.printMessage();}
}
- 修饰类:当
final
关键字修饰一个类时,表示该类不能被继承,即不能有子类。这样可以保护类的实现不被修改或继承。
示例代码:
public final class FinalClass {// 类的实现
}// 试图继承final类,编译错误
// public class SubClass extends FinalClass { }
总结:
final
修饰变量表示常量,其值不可改变;final
修饰方法表示该方法不可被重写;final
修饰类表示该类不可被继承。
更多推荐
初始java( 4 )7000字详解
发布评论