Java11-面向对象进阶-static-继承

第一章复习回顾

1.1 如何定义类

类的定义格式如下:

修饰符 class 类名 {
    // 1.成员变量（属性）
    // 2.成员方法 (行为) 
    // 3.构造方法 （初始化类的对象数据的）
}

例如:

public class Student {
    // 1.成员变量
    public String name ;
    public char sex ; // '男'  '女'
    public int age;
}

1.2 如何通过类创建对象

1	`类名对象名称 = new 类名();`

例如:

1	`Student stu = new Student();`

1.3 封装

1.3.1 封装的步骤

1.使用 private 关键字来修饰成员变量。

2.使用public修饰getter和setter方法。

1.4 构造方法

1.4.1 构造方法的作用

在创建对象的时候，给成员变量进行初始化。

初始化即赋值的意思。

1.4.2 构造方法的格式

1
2
3

修饰符 类名(形参列表) {
    // 构造体代码，执行代码
}

1.5 this关键字的作用

1.5.1 this关键字的作用

this代表所在类的当前对象的引用（地址值），即代表当前对象。

1.5.2 this关键字的应用

1.5.2.1 用于普通的gettter与setter方法

this出现在实例方法中，谁调用这个方法（哪个对象调用这个方法），this就代表谁（this就代表哪个对象）。

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
      	this.name = name;
    }

    public String getName() {
      	return name;
    }

    public void setAge(int age) {
        if (age > 0 && age < 200) {
            this.age = age;
        } else {
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
      	return age;
    }
}

1.5.2.2 用于构造方法中

this出现在构造方法中，代表构造方法正在初始化的那个对象。

public class Student {
    private String name;
    private int age;
    
    // 无参数构造方法
    public Student() {} 
    
    // 有参数构造方法
    public Student(String name,int age) {
    	this.name = name;
    	this.age = age; 
    }
}

第二章 static关键字

2.1 概述

以前我们定义过如下类：

public class Student {
    // 成员变量
    public String name;
    public char sex; // '男'  '女'
    public int age;

    // 无参数构造方法
    public Student() {

    }
    
    // 有参数构造方法
    public Student(String  a) {

    }
}

我们已经知道面向对象中，存在类和对象的概念，我们在类中定义了一些成员变量，例如name,age,sex ,结果发现这些成员变量，每个对象都存在（因为每个对象都可以访问）。

而像name ,age , sex确实是每个学生对象都应该有的属性，应该属于每个对象。

所以Java中成员（变量和方法）等是存在所属性的，Java是通过static关键字来区分的。static关键字在Java开发非常的重要，对于理解面向对象非常关键。

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被static修饰的成员是属于类的是放在静态区中，没有static修饰的成员变量和方法则是属于对象的。我们上面案例中的成员变量都是没有static修饰的，所以属于每个对象。

2.2 定义格式和使用

static是静态的意思。 static可以修饰成员变量或者修饰方法。

2.2.1 静态变量及其访问

被static修饰的成员变量，叫做静态变量（也称为类变量）。

特点：

被所有的对象共享
不属于对象属于类
随着类的加载而加载的，优先于对象出现的

定义格式

1	`修饰符 static 数据类型变量名 = 初始值；`

举例

public class Student {
    public static String schoolName = "A大学"； // 属于类，只有一份。
    // .....
}

静态变量的访问:
调用方式：

类名调用
对象名调用

格式：类名.静态变量

public static void  main(String[] args){
    System.out.println(Student.schoolName); // A大学
    Student.schoolName = "B大学";
    System.out.println(Student.schoolName); // B大学
}

static内存：
因为类只有一个，所以静态成员变量在内存区域中也只存在一份。

2.2.2 实例变量及其访问

无static修饰的成员变量属于每个对象的，这个成员变量叫实例变量，之前我们写成员变量就是实例成员变量。

需要注意的是：实例成员变量属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例成员变量

2.2.3 静态方法及其访问

有static修饰成员方法，说明这个成员方法是属于类的，这个成员方法称为类方法或者静态方法**。直接用类名访问即可。因为类只有一个，所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。

与静态成员变量一样，静态方法也是直接通过类名.方法名称即可访问。

举例

public class Student{
    public static String schoolName = "A大学"； // 属于类，只有一份。
    // .....
    public static void study(){
    	System.out.println("我们都学习");   
    }
}

特点

多用在测试类和工具类中
Javabean类中很少会用

静态成员变量的访问:

类名调用
对象名调用

格式：类名.静态方法

1
2
3

public static void  main(String[] args){
    Student.study();
}

2.2.4 实例方法及其访问

无static修饰的成员方法属于每个对象的，这个成员方法也叫做实例方法。

需要注意的是：实例方法是属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例方法

示例：

public class Student {
    // 实例变量
    private String name ;
    // 2.方法：行为
    // 无 static修饰，实例方法。属于每个对象，必须创建对象调用
    public void run(){
        System.out.println("学生可以跑步");
    }
	// 无 static修饰，实例方法
    public  void sleep(){
        System.out.println("学生睡觉");
    }
    public static void study(){
        
    }
}

public static void main(String[] args){
    // 创建对象 
    Student stu = new Student ;
    stu.name = "徐干";
    // Student.sleep();// 报错，必须用对象访问。
    stu.sleep();
    stu.run();
}

2.3 小结

1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。

2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。

3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。

4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。

静态方法中没有this关键字
==静态方法中只能调用静态==。
非静态方法可以访问所有。
静态属于类（共享），非静态属于具体对象（私有）

第三章继承

3.1 概述

3.1.1 引入

假如我们要定义如下类:
学生类和老师类，如下。

假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：

其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass) 或者基类。

子类可以直接用父类中的东西，继承就是类与类之间的父子关系。

3.1.2 继承的含义

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

3.1.3 继承的好处

提高代码的复用性（减少代码冗余，相同代码重复利用）。
使类与类之间产生了关系。
子类可以在父类的基础上，增加其他的功能，使子类更强大。

3.1.3 什么时候用继承

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

3.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
	...
}

class 子类 extends 父类 {
	...
}

继承的特点:
Java只支持单继承，不支持多继承，但支持多层继承。
单继承: 一个类只能继承一个父类，但是Java中的子类是更加强大的。
不支持多继承: 子类不能同时继承多个父类
多层继承：子类A继承父类B,父类B可以继承父类C。
每一个类都直接或者间接的继承于Object

3.3 继承案例

3.3.1 案例

现在有四种动物：布偶猫、中国狸花猫、哈士奇、泰迪。暂时不考虑属性，只要考虑行为。请按照继承的思想特点进行继承体系的设计。

四种动物分别有以下的行为：
布偶猫：吃饭、喝水、抓老鼠
中国狸花猫：吃饭、喝水、抓老鼠。
哈士奇：吃饭、喝水、看家、拆家
泰迪：吃饭、喝水、看家、蹭一蹭

3.3.2 案例图解分析

3.3.3 案例代码实现

1.父类Animal类

public class Animal {  
    public void eat() {  
        System.out.println("吃饭");  
    }  
  
    public void drink() {  
        System.out.println("喝水");  
    }  
}

2.子类Cat类

public class Cat extends Animal{  
    public void catchMouse(){  
        System.out.println("抓老鼠");  
    }  
}

3.子类Dog类

public class Dog extends Animal{  
    public void watchHome(){  
        System.out.println("看家");  
    }  
}

4.子类布偶猫类

1
2
3

public class Ragdoll extends Cat{  
      
}

5.狸花猫类

1
2
3

public class LiHua extends Cat{  
      
}

6.哈士奇类

public class Husky extends Dog{  
    public void breakHome(){  
        System.out.println("拆家");  
    }  
}

7.泰迪类

public class Teddy extends Dog{  
    public void touch(){  
        System.out.println("蹭一蹭");  
    }  
}

8.测试类

public class Test {  
    public static void main(String[] args) {  
        Ragdoll rd = new Ragdoll();  
        rd.eat();  
        rd.drink();  
        rd.catchMouse();  
  
        Husky husky = new Husky();  
        husky.eat();  
        husky.drink();  
        husky.watchHome();  
        husky.breakHome();  
    }  
}

3.3.4 小结

继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

3.4 子类不能继承的内容

3.4.1 结论

子类不能继承父类的构造方法。
值得注意的是子类可以继承父类的私有成员（成员变量，方法)，只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

3.5 继承后的特点—成员变量

3.5.1 成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
	// Fu中的成员变量
	int num = 5;
}
class Zi extends Fu {
	// Zi中的成员变量
	int num2 = 6;
  
	// Zi中的成员方法
	public void show() {
		// 访问父类中的num
		System.out.println("Fu num="+num); // 继承而来，所以直接访问。
		// 访问子类中的num2
		System.out.println("Zi num2="+num2);
	}
}
class Test {
	public static void main(String[] args) {
        // 创建子类对象
		Zi z = new Zi(); 
      	// 调用子类中的show方法
		z.show();  
	}
}

结果：
Fu num = 5
Zi num2 = 6

3.5.2 成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu1 {
	// Fu中的成员变量。
	int num = 5;
}
class Zi1 extends Fu1 {
	// Zi中的成员变量
	int num = 6;
  
	public void show() {
		int num = 7;
		
		System.out.println("num=" + num);
	}
}
class Test {
	public static void main(String[] args) {
      	// 创建子类对象
		Zi1 z = new Zi1(); 
      	// 调用子类中的show方法
		z1.show(); 
	}
}
演示结果：
num = 7

就近原则，先在局部变量中寻找（int num = 7），没有去本类中寻找（int num = 6），最后去父类中寻找（int num = 5），逐级往上。

如果此时想访问父类成员变量，我们可以使用super关键字。

3.5.3 super访问父类成员变量

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于 this 关键字。

需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用(当前类中的成员变量，不在方法里非局部)。

使用格式：

1	`super.父类成员变量名`

子类方法需要修改，代码如下：

class Fu {
	// Fu中的成员变量。
	int num = 5;
}

class Zi extends Fu {
	// Zi中的成员变量
	int num = 6;
  
	public void show() {
        int num = 1;
      
        // 访问方法中的num
        System.out.println("method num=" + num);
        // 访问子类中的num
        System.out.println("Zi num=" + this.num);
        // 访问父类中的num
        System.out.println("Fu num=" + super.num);
	}
}

class Test {
	public static void main(String[] args) {
      	// 创建子类对象
		Zi1 z = new Zi1(); 
      	// 调用子类中的show方法
		z1.show(); 
	}
}

演示结果：
method num=1
Zi num=6
Fu num=5

小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？可以在父类中提供公共的getXxx方法和setXxx方法。

3.6 继承后的特点—成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

3.6.1 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的，就近原则。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

class Fu {
	public void show() {
		System.out.println("Fu类中的show方法执行");
	}
}
class Zi extends Fu {
	public void show2() {
		System.out.println("Zi类中的show2方法执行");
	}
}

public  class Test {
	public static void main(String[] args) {
		Zi z = new Zi();
     	//子类中没有show方法，但是可以找到父类方法去执行
		z.show(); 
		z.show2();
	}
}


结果：
Fu类中的show方法执行
Zi类中的show2方法执行

3.6.2 成员方法重名

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。

代码如下：

class Fu {
	public void show() {
		System.out.println("Fu show");
	}
}
class Zi extends Fu {
	//子类重写了父类的show方法
	public void show() {
		System.out.println("Zi show");
	}
}
public class ExtendsDemo05{
	public static void main(String[] args) {
		Zi z = new Zi();
     	// 子类中有show方法，只执行重写后的show方法
		z.show();  // Zi show
		
	}
}

结果：
Zi show

3.7 方法重写

3.7.1 概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。建立在子父类关系上，同个方法名同但是内容不同就是重写。

3.7.2 使用场景与案例

当父类的方法不能满足子类现在的需求，需要进行方法重写

子类继承了父类的方法，但是子类觉得父类的这方法不足以满足自己的需求，子类重新写了一个与父类同名的方法，以便覆盖父类的该方法（覆盖虚方法表中的方法）。

例如：我们定义了一个动物类代码如下：

public class Animal  {
    public void run(){
        System.out.println("动物跑的很快！");
    }
    public void cry(){
        System.out.println("动物都可以叫~~~");
    }
}

然后定义一个猫类，猫可能认为父类cry()方法不能满足自己的需求

代码如下：

public class Cat extends Animal {
    public void cry(){
        System.out.println("猫喵喵叫");
    }
}

public class Test {
	public static void main(String[] args) {
      	// 创建子类对象
      	Cat ddm = new Cat();
        // 调用父类继承而来的方法
        ddm.run();
      	// 调用子类重写的方法
      	ddm.cry();
	}
}

3.7.2 @Override重写注解

@Override:注解，重写注解校验！
这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。

建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

加上后的子类代码形式如下：

public class Cat extends Animal {
     // 声明不变，重新实现
    // 方法名称与父类全部一样，只是方法体中的功能重写写了！
    @Override
    public void cry(){
        System.out.println("猫咪没有在叫");
    }
}

3.7.3 方法重写的本质

如果发生了重写，则会覆盖，覆盖虚方法表中的方法。

B类继承C类方法：

B类重写method2：

A类再次重写method2：

3.7.4 注意事项

方法重写是发生在子父类之间的关系。
重写方法的名称、形参列表必须与父类中的一致。
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
子类重写父类方法时，返回值类型子类必须小于等于父类
只有被添加到虚方法表中的方法才能被重写

3.8 继承后的特点—构造方法

3.8.1 特点

构造方法的名字是与类名一致的。所以子类无法继承父类构造方法的。
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。

为什么？

构造方法的作用是初始化对象成员变量数据的。子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
==子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。==

如何调用父类构造方法的？

子类构造方法的第一行语句默认都是super();==不写也存在，且必须在第一行==。
如果想调用父类有参构造，必须手动写super进行调用

继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法

3.8.2 案例演示

按如下需求定义类:

人类
成员变量: 姓名,年龄
学生类
成员变量: 姓名,年龄,成绩

代码如下：

class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("父类无参");
    }

	public Person(String name, int age) {  
	    this.name = name;  
	    this.age = age;  
	}
}

class Student extends Person {
	public Student() {  
	    //super(); // 调用父类无参,默认就存在，可以不写，必须再第一行  
	    System.out.println("子类无参");  
	}  
	public Student(String name, int age) {  
	    super(name, age);  // 调用父类有参构造  
	    System.out.println("父类有参");  
	}
}

public class Test {
    public static void main(String[] args) {
		Student s1 = new Student(); //无参构造创建对象  
		System.out.println("----------");  
  
		Student s2 = new Student("zhangsan", 23);  
		System.out.println(s2.name+" "+ s2.age);
    }
}

输出结果：
父类无参
子类无参
----------
父类有参
zhangsan 23

父类无参：

父类有参：

3.8.3 小结

子类不能继承父类的构造方法，但是可以通过super调用
子类构造方法的第一行，有一个默认的super(0:
默认先访问父类中无参的构造方法，再执行自己。
如果想要方法文父类有参构造，必须手动书写。

3.9 super(…)和this(…)总结

3.9.1 总结

this : 理解为一个变量，表示当前方法调用者的地址值；
super : 代表父类存储空间

3.9.2 super和this的用法格式

访问成员变量格式：

1
2
3

this.成员变量    	--    本类的
super.成员变量    	--    父类的

访问成员方法格式：

1 2	`this.成员方法名() -- 本类的 super.成员方法名() -- 父类的`

访问构造方法格式：

1 2	`super(...) -- 调用父类的构造方法，根据参数匹配确认 this(...) -- 调用本类的其他构造方法，根据参数匹配确认`

3.9.3 super(….)用法演示

代码如下：

class Person {
    private String name ="凤姐";
    private int age = 20;

    public Person() {
        System.out.println("父类无参");
    }
    
    public Person(String name , int age){
        this.name = name ;
        this.age = age ;
    }

    // getter/setter省略
}

class Student extends Person {
    private double score = 100;

    public Student() {
        //super(); // 调用父类无参构造方法,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(String name ， int age，double score) {
        super(name ,age);// 调用父类有参构造方法Person(String name , int age)初始化name和age
        this.score = score;    
        System.out.println("子类有参");
     }
      // getter/setter省略
}

public class Demo07 {
    public static void main(String[] args) {
        // 调用子类有参数构造方法
        Student s2 = new Student("张三"，20，99);
        System.out.println(s2.getScore()); // 99
        System.out.println(s2.getName()); // 输出 张三
        System.out.println(s2.getAge()); // 输出 20
    }
}

注意：

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

super(..)是根据参数去确定调用父类哪个构造方法的。

3.9.4 super(…)案例图解

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造七调用时，一定先调用父类的构造方法。理解图解如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fN0EXS8c-1682256310760)(./附件/13.jpg)]

3.9.5 this(…)用法演示

this(…)

默认是去找本类中的其他构造方法，根据参数来确定具体调用哪一个构造方法。
为了借用其他构造方法的功能。
一般给一些数据赋默认值时会用


public class Test {
    public static void main(String[] args) {
        Student s = new Student();
    }
}

class Student{
    private String name ;
    private int age ;
    private String school ;
		
		//需求：学校默认为xxx大学
    public Student() {
		//调用本类其他构造方法
		//虚拟机不会在添加super（）
        this(null,0,'xxx大学');
    }

    public Student(String name, int age, char sex) {
	    //不会在添加super();
        this.name = name ;
        this.age = age;
        this.school = school;
    }
  
}

注意：

this（）必须写在第一行
虚拟机不会在添加super（）

3.9.6 小结

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
super(..)和this(…)是根据参数去确定调用父类哪个构造方法的。
super(..)可以调用父类构造方法初始化继承自父类的成员变量的数据。
this(..)可以调用本类中的其他构造方法。

4. 练习

写一个继承结构下的标准Javabean

需求：
1.经理
成员变量：工号，姓名，工资，管理奖金
成员方法：工作（管理其他人），吃饭（吃米饭）

2.厨师
成员变量：工号，姓名，工资
成员方法：工作（炒菜），吃饭（吃米饭）

代码示例：

父类Worker

package extent4;  
  
public class Worker {  
    private String id;  
    private String name;  
    private double salary;  
  
  
    public Worker() {  
    }  
  
    public Worker(String id, String name, double salary) {  
        this.id = id;  
        this.name = name;  
        this.salary = salary;  
    }  
  
  
    public String getId() {  
        return id;  
    }  
  
  
    public void setId(String id) {  
        this.id = id;  
    }  
  
  
    public String getName() {  
        return name;  
    }  
  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public double getSalary() {  
        return salary;  
    }  
  
  
    public void setSalary(double salary) {  
        this.salary = salary;  
    }  
  
    public void job() {  
        System.out.println("工作");  
    }  
  
    public void eat() {  
        System.out.println("吃米饭");  
    }  
}

子类Manger

package extent4;  
  
public class Manager extends Worker {  
    private double bonus;  
  
  
    //空参构造  
    public Manager() {  
  
    }  
  
    // 带全部参数的构造（父类和子类所有的成员变量）  
    public Manager(String id, String name, double salary, double bonus) {  
        super(id, name, salary);  
        this.bonus = bonus;  
    }  
  
  
    // 只用写子类的get&set  
    public double getBonus() {  
        return bonus;  
    }  
  
    public void setBonus(double bonus) {  
        this.bonus = bonus;  
    }  
  
    @Override  
    public void job() {  
        System.out.println("管理其他人");  
    }  
}

子类Cook

package extent4;  
  
public class Cook extends Worker{  
    public Cook() {  
    }  
  
    public Cook(String id, String name, double salary) {  
        super(id, name, salary);  
    }  
  
    @Override  
    public void job() {  
        System.out.println("炒菜");  
    }  
}

测试类

package extent4;  
  
public class Test {  
    public static void main(String[] args) {  
        Manager manager = new Manager("00a", "zhangsan", 8888, 6666);  
        System.out.println(manager.getId() + ", " + manager.getName() + ", " + manager.getSalary() + ", " + manager.getBonus());  
        manager.job();  
        manager.eat();  
  
  
        Cook cook = new Cook();  
        cook.setId("002");  
        cook.setName("lisi");  
        cook.setSalary(6666);  
        System.out.println(cook.getId() + ", " + cook.getName() + ", " + cook.getSalary());  
        cook.job();  
        cook.eat();  
    }  
}

Java基础

#Java

Java11-面向对象进阶-static-继承

https://blog.966677.xyz/2023/06/29/Java11-面向对象进阶-static-继承/

作者

Zhou1317fe5

发布于

2023年6月29日

许可协议

Java12-面向对象进阶-多态&包&final&权限修饰符上一篇

Java10-集合ArrayList 下一篇

Java11-面向对象进阶-static-继承

第一章 复习回顾

1.1 如何定义类

1.2 如何通过类创建对象

1.3 封装

1.3.1 封装的步骤

1.4 构造方法

1.4.1 构造方法的作用

1.4.2 构造方法的格式

1.5 this关键字的作用

1.5.1 this关键字的作用

1.5.2 this关键字的应用

1.5.2.1 用于普通的gettter与setter方法

1.5.2.2 用于构造方法中

第二章 static关键字

2.1 概述

2.2 定义格式和使用

2.2.1 静态变量及其访问

2.2.2 实例变量及其访问

2.2.3 静态方法及其访问

2.2.4 实例方法及其访问

2.3 小结

第三章 继承

3.1 概述

3.1.1 引入

3.1.2 继承的含义

3.1.3 继承的好处

3.1.3 什么时候用继承

3.2 继承的格式

3.3 继承案例

3.3.1 案例

3.3.2 案例图解分析

3.3.3 案例代码实现

3.3.4 小结

3.4 子类不能继承的内容

3.4.1 结论

3.5 继承后的特点—成员变量

3.5.1 成员变量不重名

3.5.2 成员变量重名

3.5.3 super访问父类成员变量

3.6 继承后的特点—成员方法

3.6.1 成员方法不重名

3.6.2 成员方法重名

3.7 方法重写

3.7.1 概念

3.7.2 使用场景与案例

3.7.2 @Override重写注解

3.7.3 方法重写的本质

3.7.4 注意事项

3.8 继承后的特点—构造方法

3.8.1 特点

3.8.2 案例演示

3.8.3 小结

3.9 super(…)和this(…)总结

3.9.1 总结

3.9.2 super和this的用法格式

3.9.3 super(….)用法演示

3.9.4 super(…)案例图解

3.9.5 this(…)用法演示

3.9.6 小结

4. 练习

第一章复习回顾

第三章继承