黑马Java——面向对象进阶（static&继承）

小琪爱学习

已于 2024-01-28 22:11:35 修改

阅读量524

点赞数 7

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

于 2024-01-24 22:25:17 首次发布

本文链接：https://blog.csdn.net/pangyaqi/article/details/135832685

版权

Java黑马专栏收录该内容

20 篇文章 1 订阅

订阅专栏

练习：带有继承结构的标准Javabean类

练习：编写带有接口和抽象类的标准的Javabean类

7.接口

7.1练习编写带有接口和抽象类的标准Javabean类

1.static静态变量

静态变量是随着类的加载而加载的，优先与对象出现的

练习1：定义数组工具类

需求:在实际开发中，经常会遇到一些数组使用的工具类
请按照如下要求编写一个数组的工具类: ArrayUtil
提供一个工具类方法printArr，用于返回整数数组的内容
返回的字符串格式如:[10,20,50,34,100](只考虑整数数组，且只考虑一维数组)
提供这样一个工具方法getAerage，用于返回平均分。(只考虑浮点型数组，且只考虑一维数组)
定义一个测试类TestDemo，调用该工具类的工具方法，并返回结果

package com.yaqi.a02staticdemo2;

public class ArrayUtil {
    //私有化构造方法
    //目的：为了不让外界创建他的对象

    //需要定义为静态的，方便调用
    public static String printArr(int[] arr) {
        StringBuilder sb = new StringBuilder();
        //拼接字符串
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            //i索引  arr[i]元素
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    public static double getAverage(double[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        //平均分
        return sum / arr.length;
    }
}

package com.yaqi.a02staticdemo2;

public class TestDemo {
    public static void main(String[] args) {
        //测试工具类中的两个方法是否正确

        int[] arr1 = {1, 2, 3, 4, 5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);

        double[] arr = {1.5, 3.7, 4.9, 5.8, 6.6};
        double avg = ArrayUtil.getAverage(arr);
        System.out.println("平均值为"+avg);
    }
}

练习2：定义学生工具类

需求：定义一个集合，用于存储3个学生对象。学生类的属性为：name、age、gender。
定义一个工具类，用于获取集合中最大学生的年龄。

学生类：

package com.yaqi.a03staticdemo3;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

工具类：

package com.yaqi.a03staticdemo3;

import java.util.ArrayList;

public class StudentUtil {

    private StudentUtil(){}

    //静态方法
    public static int getMaxAgeStudent(ArrayList<Student> list){
        //1.定义一个参照物
        int max  = list.get(0).getAge();

        //2.循环遍历集合
        for (int i = 0; i < list.size(); i++) {
            //i索引  list.get(i)元素/学生对象   我们还需要
            int tempAge = list.get(i).getAge();
            if(tempAge>max){
                max = tempAge;
            }
        }
        //直接返回max
        return max;
    }
}

测试类：

package com.yaqi.a03staticdemo3;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //1.创建一个集合用来储存学生对象
        ArrayList<Student> list = new ArrayList<>();

        //2.创建3个学生对象
        Student stu1 = new Student("zhangsan", 23, "男");
        Student stu2 = new Student("lisi", 24, "男");
        Student stu3 = new Student("wangwu", 25, "男");

        //3.把学生对象添加到集合当中
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        //4.调用工具类中的方法
        int maxAgeStudent = StudentUtil.getMaxAgeStudent(list);
        System.out.println(maxAgeStudent);
    }

}

2.继承

封装：对象代表什么，就得封装对应的数据，并提供数据对应的行为

继承：是面向对象三大特征之一，可以让类跟类之间产生父与子的关系

练习：继承的练习（自己设计一个继承体系）

现在有四种动物：布偶猫、中国狸花猫、哈士奇、泰迪。

暂时不考虑属性，只要考虑行为。请按照继承的思想特点进行继承体系的设计。

四种动物分别有以下的行为：

布偶猫：吃饭、喝水、抓老鼠
中国狸花猫：吃饭、喝水、抓老鼠
哈士奇：吃饭、喝水、看家、拆家
泰迪：吃饭、喝水、看家、蹭一蹭

package a01oopextendsdemo1;

public class Animal {

    //权限修饰符：
    //private ：子类就无法访问了
    //私有：只能在本类中访问
    //爸爸的私房钱（自己使用）

    //注意事项：
    //子类只访问父类中非私有的成员变量
    public void eat(){
        System.out.println("吃东西");
    }

    public void drink(){
        System.out.println("喝水");
    }
}

//猫
package a01oopextendsdemo1;

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

//狗
package a01oopextendsdemo1;

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

}


//哈士奇
package a01oopextendsdemo1;

public class Husky extends Dog {
    public void breakHome(){
        System.out.println("哈士奇正在拆家");
    }
}

//狸花猫
package a01oopextendsdemo1;

public class LiHua extends Cat {
}


package a01oopextendsdemo1;

public class Ragdoll extends Cat {

}

//泰迪
package a01oopextendsdemo1;

public class Teddy extends Dog {
    public void touch(){
        System.out.println("泰迪又在蹭我的腿了");
    }
}


//测试类
package a01oopextendsdemo1;

public class Test {
    public static void main(String[] args) {
        //创建对象

        //1.创建布偶猫的对象
        Ragdoll rd = new Ragdoll();
        rd.eat();
        rd.drink();
        rd.catchMouse();

        //2.创建一个哈士奇的对象
        Husky h = new Husky();
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();
    }
}

成员变量无论是否私有，都可以继承父类，但是不能被调用(不能使用)。

如果想使用，需要用相应的get，set方法。

练习利用方法的重写设计继承结构

现在有三种动物：哈士奇、沙皮狗、中华田园犬暂时不考虑属性，只要考虑行为。

请按照继承的思想特点进行继承体系的设计。三种动物分别有以下的行为：

哈士奇：吃饭（吃狗粮）、喝水、看家、拆家
沙皮狗：吃饭（吃狗粮、吃骨头）、喝水、看家
中华田园犬：吃饭（吃剩饭）、喝水、看家

//父类狗
package a07oopextendsdemo7;

public class Dog {

    public void eat(){
        System.out.println("狗在吃东西");
    }

    public void drink(){
        System.out.println("狗在喝水");
    }

    public void lookHome(){
        System.out.println("狗在看家");
    }
}

//哈士奇
package a07oopextendsdemo7;

public class Husky extends Dog{

    //哈士奇有一个额外的方法拆家
    public void breakHome(){
        System.out.println("哈士奇正在拆家");
    }

}


//沙皮狗

package a07oopextendsdemo7;

public class SharPei extends Dog{

    //因为沙皮狗吃的狗粮和骨头
    //父类中的方法不能满足我们的需求，所以要进行重写


    @Override
    public void eat() {
        super.eat();//吃狗粮
        System.out.println("啃骨头");
    }
}


//中华田园犬
package a07oopextendsdemo7;

public class ChineseDog extends Dog{

    //父类中的方法不能满足我们的需求了，所以需要进行重写
    //而且中华田园犬完全用不到父类中的代码，所以不需要通过super进行调用


    @Override
    public void eat() {
        System.out.println("吃剩饭");
    }
}


//测试狗

package a07oopextendsdemo7;

public class DogTest {
    public static void main(String[] args) {
        //创建对象并调用

        Husky h  = new Husky();
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();

        ChineseDog cd = new ChineseDog();
        cd.eat();
        cd.drink();
        cd.lookHome();

    }

}

访问本类构造方法的使用场景：需要设置默认值的时候。

练习：带有继承结构的标准Javabean类

1.经理：成员变量：工号、姓名、工资、管理资金；成员方法：工作(管理其他人)、吃饭(吃白米饭)

2.厨师：成员变量：工号、姓名、工资；成员方法：工作(炒菜)、吃饭(吃米饭)

package a010oopextendsdemo10;
//职工类
public class Employee {
    //1.类名见知意
    //2.所有的成员变量都需要私有
    //3.构造方法（空参  带全部参数的构造）
    //4.get/set

    private String id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(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 work(){
        System.out.println("员工在工作");
    }

    //吃饭
    public void eat(){
        System.out.println("吃米饭");
    }
}


package a010oopextendsdemo10;
//继承
//管理类
public class Manager extends Employee{

    private double bouns;

    //空参构造
    public Manager() {
    }

    //带全部参数的构造
    //父类 + 子类
    public Manager(String id, String name, double salary, double bouns) {
        super(id, name, salary);
        this.bouns = bouns;
    }

    public double getBouns() {
        return bouns;
    }

    public void setBouns(double bouns) {
        this.bouns = bouns;
    }

    @Override
    public void work() {
        System.out.println("管理其他人");
    }
}


package a010oopextendsdemo10;
//厨师类
public class Cook extends Employee{

    public Cook() {
    }

    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }

    @Override
    public void work() {
        System.out.println("厨师正在炒菜");
    }
}

package a010oopextendsdemo10;
//测试类
public class Test {
    public static void main(String[] args) {
        //创建对象并赋值调用

        Manager m =new Manager("heima001","张三",15000,8000);
        System.out.println(m.getId()+","+m.getName()+","+m.getSalary()+","+m.getBouns());
        m.work();
        m.eat();

        Cook c =new Cook();
        c.setId("heima002");
        c.setName("李四");
        c.setSalary(8000);
        System.out.println(c.getId()+","+c.getName()+","+c.getSalary());
        c.work();
        c.eat();
    }
}