黑马Java——面向对象进阶（static&继承）-Toy模板网

这篇具有很好参考价值的文章主要介绍了黑马Java——面向对象进阶（static&继承）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.static静态变量

练习1：定义数组工具类

练习2：定义学生工具类

2.继承

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

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

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

3.多态

多态的综合练习

4.包和final

4.1包

4.2final

5.权限修饰符和代码块

5.1权限修饰符

5.2代码块

6.抽象类和抽象方法

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

7.接口

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

7.2JDK8以后接口中新增的方法

7.3适配器

8.内部类

8.1静态内部类

8.2局部内部类

8.3匿名内部类

1.static静态变量

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

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

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

练习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);
    }
}

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

练习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);
    }

}

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

2.继承

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

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

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

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

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

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

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

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

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方法。

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

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

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

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

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

//父类狗
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();

    }

}

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

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

练习：带有继承结构的标准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();
    }
}

3.多态

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

多态的综合练习

根据需求完成代码:
   1.定义狗类
       属性：
           年龄，颜色
       行为:
           eat(String something)(something表示吃的东西)
           看家lookHome方法(无参数)

   2.定义猫类
       属性：
           年龄，颜色
       行为:
           eat(String something)方法(something表示吃的东西)
           逮老鼠catchMouse方法(无参数)

   3.定义Person类//饲养员
       属性：
           姓名，年龄
       行为：
           keepPet(Dog dog,String something)方法
               功能：喂养宠物狗，something表示喂养的东西
       行为：
           keepPet(Cat cat,String something)方法
               功能：喂养宠物猫，something表示喂养的东西
       生成空参有参构造，set和get方法
   4.定义测试类(完成以下打印效果):
       keepPet(Dog dog,String somethind)方法打印内容如下：
           年龄为30岁的老王养了一只黑颜色的2岁的狗
           2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
       keepPet(Cat cat,String somethind)方法打印内容如下：
           年龄为25岁的老李养了一只灰颜色的3岁的猫
           3岁的灰颜色的猫眯着眼睛侧着头吃鱼
   5.思考：
       1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
       2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

package com.yaqi.a04polymorphismdemo4;

//动物类（父类）
public class Animal {

    /*
    属性：
    年龄，颜色
    行为：
    eat(String something)(something表示吃的东西)
     */
    private int age;
    private String color;

    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String somthing){
        System.out.println("动物在吃"+somthing);
    }
}

狗类

package com.yaqi.a04polymorphismdemo4;

//狗类
public class Dog extends Animal{
    /*1.定义狗类
		属性：
			年龄，颜色
		行为:
			eat(String something)(something表示吃的东西)
			看家lookHome方法(无参数)
     */

    //空参构造
    //带全部参数的构造


    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    //行为:
    //eat(String something)(something表示吃的东西)
    //看家lookHome方法(无参数)

    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃");
    }

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

猫类

package com.yaqi.a04polymorphismdemo4;

//猫类
public class Cat extends Animal {
    /*
    2.定义猫类

	行为:
		eat(String something)方法(something表示吃的东西)
		逮老鼠catchMouse方法(无参数)
    */

    //空参构造
    //带全部参数的构造
    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }

    //行为:
    //eat(String something)方法(something表示吃的东西)
    //逮老鼠catchMouse方法(无参数)

    @Override
    public void eat(String somthing) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的猫咪着眼睛侧着头吃" + somthing);
    }

    public void catachMouse() {
        System.out.println("猫抓老鼠");
    }
}

人类

package com.yaqi.a04polymorphismdemo4;

//人类
public class Person {
    /*3.定义Person类//饲养员
		属性：
			姓名，年龄
		行为：
			keepPet(Dog dog,String something)方法
				功能：喂养宠物狗，something表示喂养的东西
		行为：
			keepPet(Cat cat,String something)方法
				功能：喂养宠物猫，something表示喂养的东西
		生成空参有参构造，set和get方法

     */

    //属性：
    //姓名，年龄
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

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

   /* keepPet(Dog dog,String somethind)方法打印内容如下：
    年龄为30岁的老王养了一只黑颜色的2岁的狗
			2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
    keepPet(Cat cat,String somethind)方法打印内容如下：
    年龄为25岁的老李养了一只灰颜色的3岁的猫
			3岁的灰颜色的猫眯着眼睛侧着头吃鱼*/
    //饲养狗
   /* public void keepPet(Dog dog, String something) {
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
        dog.eat(something);
    }

    //饲养猫
    public void keepPet(Cat cat, String something) {
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
        cat.eat(something);
    }*/


    //想要一个方法，能接收所有的动物，包括猫，包括狗
    //方法的形参：可以写这些类的父类 Animal
    public void keepPet(Animal a,String something){
        if(a instanceof Dog){

            Dog d = (Dog) a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + d.getColor() + "颜色的" + d.getAge() + "岁的狗");
            d.eat(something);
        }else if(a instanceof Cat){
            Cat c = (Cat) a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");

             c.eat(something);
        }else{
            System.out.println("没有这种动物");
        }
    }
}

测试类

package com.yaqi.a04polymorphismdemo4;

/*
需求：根据需求完成代码:
	1.定义狗类
		属性：
			年龄，颜色
		行为:
			eat(String something)(something表示吃的东西)
			看家lookHome方法(无参数)
2.定义猫类
	属性：
		年龄，颜色
	行为:
		eat(String something)方法(something表示吃的东西)
		逮老鼠catchMouse方法(无参数)
3.定义Person类//饲养员
	属性：
		姓名，年龄
	行为：
		keepPet(Dog dog,String something)方法
			功能：喂养宠物狗，something表示喂养的东西
	行为：
		keepPet(Cat cat,String something)方法
			功能：喂养宠物猫，something表示喂养的东西
	生成空参有参构造，set和get方法
4.定义测试类(完成以下打印效果):
	keepPet(Dog dog,String somethind)方法打印内容如下：
		年龄为30岁的老王养了一只黑颜色的2岁的狗
		2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
	keepPet(Cat cat,String somethind)方法打印内容如下：
		年龄为25岁的老李养了一只灰颜色的3岁的猫
		3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考：
	1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
	2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？
 */
public class Test {
    public static void main(String[] args) {
        //创建对象并调用方法
       /* Person p1 = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        p1.keepPet(d,"骨头");


        Person p2 = new Person("老李",25);
        Cat c = new Cat(3,"灰");
        p2.keepPet(c,"鱼");*/


        //创建饲养员的对象
        Person p = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        Cat c = new Cat(3,"灰");
        p.keepPet(d,"骨头");
        p.keepPet(c,"鱼");

    }
}

4.包和final

4.1包

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

全类名

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

4.2final

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

5.权限修饰符和代码块

5.1权限修饰符

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

5.2代码块

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

6.抽象类和抽象方法

一个方法抽取到父类中，不确定方法体，用abstract关键字修饰(抽象方法)，子类会被强制重写，否则就直接报错。抽象方法所在的类，就是抽象类。

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

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

青蛙属性：名字，年龄行为：吃虫子，游泳

狗属性：名字，年龄行为：吃骨头，狗刨

兔子属性：名字，年龄行为：吃胡萝卜

package com.yaqi.a01interfacedemo1;
//动物类
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

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

package com.yaqi.a01interfacedemo1;
//接口（游泳）
public interface Swim {

    public abstract void swim();

}

package com.yaqi.a01interfacedemo1;
//青蛙
public class Frog extends Animal implements Swim{

    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

package com.yaqi.a01interfacedemo1;
//狗
public class Dog extends Animal implements Swim {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

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

    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}

package com.yaqi.a01interfacedemo1;
//兔子
public class Rabbit extends Animal {

    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }
}

package com.yaqi.a01interfacedemo1;
//测试类
public class Test {
    public static void main(String[] args) {
        //创建青蛙的对象
        Frog f = new Frog("小青",1);
        System.out.println(f.getName()+","+f.getAge());

        f.eat();
        f.swim();

        //创建兔子对象
        Rabbit r = new Rabbit("小白",2);
        System.out.println(r.getName()+","+r.getAge());

        r.eat();

        //创建狗对象
        Dog d = new Dog("小黑",3);
        System.out.println(d.getName()+","+d.getAge());

        d.eat();
        d.swim();
    }
}

7.接口

//接口的定义格式：
interface 接口名称{
    // 抽象方法
}

// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

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

思路1：

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

思路2：

按照思路2编写代码：

package com.yaqi.a05interfacedemo5;
//Person类
public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

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

//教练类
package com.yaqi.a05interfacedemo5;

public abstract class Sporter extends Person {

    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

//乒乓球教练类

public class PingPangCoach extends Coach implements English {

    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练正在教如何打乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在学习说英语");
    }
}

//篮球教练类

public class BasketballCoach extends Coach{

    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练正在教如何打篮球");
    }
}

//运动员类

public abstract class Sporter extends Person {

    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

package com.yaqi.a05interfacedemo5;

public class PingPangSporter extends Sporter implements  English {

    public PingPangSporter() {
    }

    public PingPangSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员讲英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习如何打乒乓球");
    }
}

//篮球运动员类
public class BasketballSporter extends Sporter {


    public BasketballSporter() {
    }

    public BasketballSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学校如何打篮球");
    }
}


//英语接口
public interface English {
    public abstract void speakEnglish();
}

//测试类

public class Test {
    public static void main(String[] args) {
        //创建运动员或教练的对象

        PingPangSporter pps = new PingPangSporter("刘诗雯", 23);
        System.out.println(pps.getName()+", "+pps.getAge());
        pps.study();
        pps.speakEnglish();
    }
}

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

7.2JDK8以后接口中新增的方法

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

7.3适配器

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

8.内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

8.1静态内部类

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

代码示例：黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

运行结果

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

8.2局部内部类

局部内部类，跟局部变量相似

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

8.3匿名内部类

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

紫色框内是一个没有名字的类，Swim接口跟这个类是实现关系，new的是紫色框内的对象，（）说明是空参构造

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

紫色框内是一个没有名字的类，Animal跟这个类是继承关系，
Animal是这个类的父类，new的是紫色框内的对象，（）说明是空参构造

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言

 method里面new Animal......的内容，可以看成是Animal的一个子类对象。

应用场景：使用某个类，只使用一次，单独定义一个类太麻烦，用匿名内部类的方法，可以简化代码。

总结：

黑马Java——面向对象进阶（static&继承）,Java黑马,java,开发语言文章来源地址https://www.toymoban.com/news/detail-822819.html

到了这里，关于黑马Java——面向对象进阶（static&继承）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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

1.static静态变量

练习1：定义数组工具类

练习2：定义学生工具类

2.继承

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

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

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

3.多态

多态的综合练习

4.包和final

4.1包

4.2final

5.权限修饰符和代码块

5.1权限修饰符

5.2代码块

6.抽象类和抽象方法

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

7.接口

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

7.2JDK8以后接口中新增的方法

7.3适配器

8.内部类

8.1静态内部类

8.2局部内部类

8.3匿名内部类

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2

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

1.static静态变量

练习1：定义数组工具类

练习2：定义学生工具类

2.继承

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

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

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

3.多态

多态的综合练习

4.包和final

4.1包

4.2final

5.权限修饰符和代码块

5.1权限修饰符

5.2代码块

6.抽象类和抽象方法

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

7.接口

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

7.2JDK8以后接口中新增的方法

7.3适配器

8.内部类

8.1静态内部类

8.2局部内部类

8.3匿名内部类

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2

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

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