11Java面向对象进阶 - static、继承

最新推荐文章于 2024-07-27 13:31:57 发布

Zhou1317fe5

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量416

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/j256904767/article/details/130331036

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

第一章复习回顾

1.1 如何定义类

类的定义格式如下:

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

例如:

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

1.2 如何通过类创建对象

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

例如:

Student stu = new Student();

1.3 封装

1.3.1 封装的步骤

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

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

1.4 构造方法

1.4.1 构造方法的作用

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

初始化即赋值的意思。

1.4.2 构造方法的格式

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

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修饰的成员变量，叫做静态变量（也称为类变量）。

特点：

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

定义格式

修饰符 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类中很少会用

静态成员变量的访问:

类名调用
对象名调用

格式：类名.静态方法

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.子类布偶猫类

public class Ragdoll extends Cat{  
      
}

5.狸花猫类

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代表的是当前对象的引用(当前类中的成员变量，不在方法里非局部)。

请添加图片描述

使用格式：

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的用法格式

访问成员变量格式：

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

访问成员方法格式：

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

访问构造方法格式：

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();  
    }  
}

Zhou1317fe5

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
11Java面向对象进阶 - static、继承

/ 成员变量 public String name;// '男' '女' public int age;// 无参数构造方法 public Student() {} // 有参数构造方法 public Student(String a) {} }我们已经知道面向对象中，存在类和对象的概念，我们在类中定义了一些成员变量，例如name,age,sex ,结果发现这些成员变量，每个对象都存在（因为每个对象都可以访问）。
复制链接

扫一扫