初始java（ 4 ）7000字详解
一：继承
1.1 继承的引入
首先我们来说说为什么要有继承，继承在生活中的体现是什么
家族是一个很好的继承的例子。在一个家族中，孩子可以继承父母的财产、姓氏、遗传特征等。家族中的子孙代表了继承关系中的子类，而父母代表了父类。在继承中，我们是不是会继承一些父类的属性（财产、姓氏、遗传特征等）和行为呢？
所以同样在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中，只有被初始化好了的变量才能够被继承，这就意味着当我们继承父类的时候，我们要先帮助从父类继承过来的那些变量进行初始化，谈到初始化，我们自然就很容易想到构造方法
所以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修饰类表示该类不可被继承。