3.1_.Net

相关链接

Part8 【面向对象】关键字(final,static)，抽象类，接口，包
- 1 final和static关键字
- - 1.1 final关键字的概述及特点
  - 1.2 static关键字的概述及特点
  - 1.3 static方法的访问特点及注意事项
  - 1.4 为什么静态成员、静态方法中不能用this和super关键字
- 2 抽象类 abstract
- - 2.1 抽象类的特点
  - 2.2 抽象类的成员的特点
  - 2.3 抽象类的练习之老师案例
- 3 接口 interface
- - 3.1 接口的成员特点
  - 3.2 类与类_类与接口_接口与接口的关系
  - 3.3 抽象类与接口的区别
  - 3.4 接口的练习
  - - 3.4.1 接口的练习之猫狗案例
    - 3.4.2 接口的练习之运动员和教练案例
- 4.包 package
- - 4.1 包的概述和注意事项
  - 4.2 导包的格式及使用
  - 4.3 ==四种权限修饰符的概述和访问特点==
- 5.课后练习
- - 5.1 练习1 经理、程序员
  - 5.2 练习2 抽象动物、犬类、缉毒犬类、技能接口
  - 5.3 练习3 新旧手机、手机行为接口
  - 5.4 主人、动物抽象、猫、狗、==instanceof==

Part8 【面向对象】关键字(final,static)，抽象类，接口，包

1 final和static关键字

1.1 final关键字的概述及特点

final关键字是最终的意思，可以修饰类，成员变量(在类中，方法外)，成员方法。
- 修饰类，类不能被继承
- 修饰变量，变量就成了常量，只能被赋值一次
- 修饰方法，方法不能被重写

案例代码一 final关键字的概述及特点【1.a 父类】

package com.groupies.base.day08;


public class Demo1POJO {
    public  final void method(){
        System.out.println("method father");
    }
}

案例代码一 final关键字的概述及特点【1.a.1 子类】

package com.groupies.base.day08;


public class Demo1POJOExtendSon extends Demo1POJO{
    public final int age = 20;

    public void show(){
        //age=10;
        System.out.println(age);
    }

    //fianl修饰的父类方法不能被重写
    
}

案例代码一 final关键字的概述及特点【1.b 父类和子类的测试类】

package com.groupies.base.day08;


public class Demo1 {
    public static void main(String[] args) {
        Demo1POJOExtendSon son = new Demo1POJOExtendSon();
        son.show();//20
        son.method();//method father
    }
}

1.2 static关键字的概述及特点

静态static的概述
- 当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
  可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。
静态static的特点
- 被类的所有对象共享
  - 这也是我们判断是否使用静态关键字的条件
- 可以通过类名调用
- 优先于对象存在
- 随着类的加载而加载

案例代码二 static关键字的概述及特点【2.a 学生类】

package com.groupies.base.day08;


public class Demo2POJOStudent {
    public String name;
    public int age;
    //public String graduateFrom; //毕业院校
    public static String graduateFrom; //毕业院校

    public void show() {
        System.out.println(name + "---" + age + "---" + graduateFrom);
    }
}

案例代码二 static关键字的概述及特点【2.b 学生类的测试类】

package com.groupies.base.day08;


public class Demo2 {
    public static void main(String[] args) {
        //B:可以通过类名直接访问
        Demo2POJOStudent.graduateFrom = "传智学院";
        Demo2POJOStudent s1 = new Demo2POJOStudent();

        s1.name = "林青霞";
        s1.age = 30;

        //E:不应该通过实例访问静态成员
        //s1.graduateFrom = "传智学院";

        s1.show();//林青霞---30---传智学院
        System.out.println("----------------------");

        Demo2POJOStudent s2 = new Demo2POJOStudent();
        s2.name = "刘德华";
        s2.age = 28;
        //s2.graduateFrom = "传智学院";
        s2.show();//刘德华---28---传智学院
    }
}

1.3 static方法的访问特点及注意事项

静态方法的访问特点
- 静态方法只能访问静态的成员变量和静态的成员方法
- 静态方法的注意事项
  - 在静态方法中是没有this,super关键字的
    - 静态的内容是随着类的加载而加载
    - this 和 super 是随着对象的创建而存在

1.4 为什么静态成员、静态方法中不能用this和super关键字

在问题之前先讲super的用法：

1.1 super 的用法跟 this 类似，this 代表对本类对象的引用，指向本类已经创建的对象；而 super 代表对父类对象的引用，指向父类对象；
1.2 静态优先于对象存在；
1.3 由上面的 1.1 和 1.2 知：
因为静态优先于对象存在，所以方法被静态修饰之后方法先存在，而方法里面要用到super指向的父类对象，但是所需的父类引用对象晚于该方法出现，也就是super所指向的对象没有，当然就会出错。
综上，静态方法中不可以出现super关键字。

在静态方法中是不能使用this预定义对象引用的,即使其后边所操作的也是静态成员也不行.
因为this代表的是调用这个函数的对象的引用，而静态方法是属于类的,不属于对象，静态方法成功加载后，对象还不一定存在

你要明白对象和类的区别。
this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西
所有的成员方法,都有一个默认的的参数this(即使是无参的方法),只要是成员方法,编译器就会给你加上this这个参数如:
Class A中
void method1(){} 实际上是这样的--------> void method1(A this)
void method2(int x){} 实际上是这样的--------> void method2(A this, intx)
而静态方法与对象无关,根本不能把对象的引用传到方法中,所以不能用this

在一个类中定义一个方法为static，则为静态方法，那就是说，无需本类的对象即可调用此方法，调用一个静态方法就是“类名.方法名”

既然"无需本类的对象即可调用静态方法"，而this和super关键字都是用于本类对象的－－－－－调用静态方法无需本类的对象这句话很清楚表明：静态方法中不能用this和super关键字

静态方法是存放在内存中的数据段里，this 和 super 调用的是堆空间里的应用对象，不能调用数据段区域里的数据，因此静态方法中不能用 this 和 super 关键字

静态方法和静态类不属于单个对象，而是类的所有对象共享使用，而 this 代表当前对象

静态方法等公用同一段存储区

案例代码三 static方法的访问特点及注意事项【3 学生类】

package com.groupies.base.day08;


public class Demo3POJO {
    //非静态的成员变量
    private String name = "林青霞";
    //静态的成员变量
    private static int age = 30;

    //A.非静态的成员方法
    public void show() {

        //a1.非静态的成员方法能访问非静态的成员变量
        this.name = "刘德华";
        System.out.println(name);

        //a2.非静态的成员方法能访问静态的成员变量
        System.out.println(age);

        //a3.非静态的成员方法能访问非静态的成员方法
        show3();

        //a4.非静态的成员方法能访问静态的成员方法
        show4();
    }

    //B.静态的成员方法
    public static void show2() {
        //c1:静态成员方法中不能出现this,super这样的关键字。
        //this.age;
        //this.name;

        //b1.静态成员方法不能访问非静态成员变量
        //System.out.println(name);

        //b2.静态的成员方法能访问静态的成员变量
        System.out.println(age);

        //b3.静态的成员方法能访问静态的成员方法
        show3();

        //b4.静态成员方法不能访问非静态成员方法
        //show4();
    }

    
    public static void show3() {
    }

    
    public void show4() {
    }
}

2 抽象类 abstract

抽象类概述
- 当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具回想前面我们的猫狗案例，提取出了一个动物类，这个时候我们是可以通过Animal a = new Animal();来创建动物对象的，其实这是不对的。为什么呢？因为，我说动物，你知道我说的是什么动物吗？只有看到了具体的动物，你才知道，这是什么动物。
- 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
- 同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
- 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

案例代码四 static方法的访问特点及注意事项【4.a 动物抽象类】

package com.groupies.base.day08;


public abstract class Demo4Abstract {
    

    //抽象方法
    public abstract void eat();

}

案例代码四 static方法的访问特点及注意事项【4.b 动物抽象类的测试类】

package com.groupies.base.day08;


public class Demo4 {
    public static void main(String[] args) {
        //抽象类和抽闲方法不能被实例化
        //Demo4Abstract a = new Demo4Abstract();
    }
}

2.1 抽象类的特点

抽象类和抽象方法必须用abstract关键字修饰
- 格式:
```
public abstract class 类名 {}

public abstract void eat();
```
- 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
- 抽象类不能实例化
  - 那么，抽象类如何实例化呢?
  - 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- 抽象类的子类
  - 要么是抽象类
  - 要么重写抽象类中的所有抽象方法

案例代码五抽象类的特点【5.a 动物抽象类】

package com.groupies.base.day08;


public abstract class Demo5AbstractAnimal {
    //抽象方法
    public abstract void eat();
    public void sleep() {
        System.out.println("睡觉");
    }
}

案例代码五抽象类的特点【5.a.1 动物抽象类子类–猫类】

package com.groupies.base.day08;


public class Demo5ExtendCat extends Demo5AbstractAnimal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

案例代码五抽象类的特点【5.a.2 动物抽象类子类–狗类】

package com.groupies.base.day08;


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

案例代码五抽象类的特点【5.b 动物抽象的测试类】

package com.groupies.base.day08;


public class Demo5 {
    public static void main(String[] args) {
        //创建对象 （C:抽象类不能实例化）
        //Demo5AbstractAnimal animal = new Demo5AbstractAnimal();
   
        //c1:参照多态的方式，通过子类对象实例化
        Demo5AbstractAnimal cat = new Demo5ExtendCat();
        cat.eat();//猫吃鱼
        cat.sleep();//睡觉
    }
}

2.2 抽象类的成员的特点

成员变量
- 可以是变量
- 也可以是常量
构造方法
- 有构造方法，但是不能实例化
- 那么，构造方法的作用是什么呢?
  - 用于子类访问父类数据的初始化
成员方法
- 可以有抽象方法限定子类必须完成某些动作
- 也可以有非抽象方法提高代码复用性

案例代码六抽象类的成员的特点【6.a 人类抽象类】

package com.groupies.base.day08;


public abstract class Demo6AbstractPerson {
    private int age = 20;
    private final String country = "中国";

    public Demo6AbstractPerson() {
    }

    public Demo6AbstractPerson(int age) {
        this.age = age;
    }

    public void show() {
        age = 30;
        System.out.println(age);
        //country = "美国";
        System.out.println(country);
    }

    public abstract void eat();
}

案例代码六抽象类的成员的特点【6.a.1 人类抽象类的子类–学生类】

package com.groupies.base.day08;


public class Demo6ExtendStudent extends Demo6AbstractPerson {
    @Override
    public void eat() {
        System.out.println("学生吃土");
    }
}

案例代码六抽象类的成员的特点【6.b 人类抽象类的测试类】

package com.groupies.base.day08;


public class Demo6 {
    public static void main(String[] args) {
        Demo6AbstractPerson student = new Demo6ExtendStudent();
        student.show(); //30
                        //中国
        student.eat();//学生吃土
    }
}

2.3 抽象类的练习之老师案例

老师案例
- 具体事物：基础班老师，就业班老师
- 共性：姓名，年龄，讲课。

案例代码七抽象类的练习之老师案例【7.a 老师抽象类】

package com.groupies.base.day08;


public abstract class Demo7AbstractTeacher {
    private String name;
    private int age;

    public Demo7AbstractTeacher(){}

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

案例代码七抽象类的练习之老师案例【7.a.1 老师抽象类的子类–基础班老师】

package com.groupies.base.day08;


public class Demo7ExtendBasicTeacher extends Demo7AbstractTeacher {
    public Demo7ExtendBasicTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("基础班老师讲解JavaSE的内容");
    }
}

案例代码七抽象类的练习之老师案例【7.a.2 老师抽象类的子类–就业班老师】

package com.groupies.base.day08;


public class Demo7ExtendWorkTeacher extends Demo7AbstractTeacher {
    public Demo7ExtendWorkTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("就业班老师讲解JavaEE的内容");
    }
}

案例代码七抽象类的练习之老师案例【7.b 老师抽象类的测试类】

package com.groupies.base.day08;


public class Demo7 {
    public static void main(String[] args) {
        //使用的是具体的类的对象
        //基础班老师 BasicTeacher

        //多态形式的测试
            //java: 不兼容的类型: com.groupies.base.day08.Demo7ExtendWorkTeacher无法转换为com.groupies.base.day08.Demo7ExtendBasicTeacher
            //Demo7ExtendBasicTeacher teacher = new Demo7ExtendBasicTeacher();
        Demo7AbstractTeacher teacher = new Demo7ExtendBasicTeacher();

        teacher.setName("林青霞");
        teacher.setAge(30);
        //林青霞---30
        System.out.println(teacher.getName() + "---" + teacher.getAge());

        //基础班老师讲解JavaSE的内容
        teacher.teach();
        System.out.println("------------------");

        teacher = new Demo7ExtendWorkTeacher("林青霞", 30);
        //林青霞---30
        System.out.println(teacher.getName() + "---" + teacher.getAge());
    }
}

3 接口 interface

接口的概述
- 继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。
- 但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。
- 所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
- 所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被训练，只需要这部分猫狗把这些额外功能实现即可。

接口的特点
- 格式：
  - ```
  public interface 接口名 {}
```
- 类实现接口 (用 implements 表示)
  - 格式
    - ```
    public class 类名 implements 接口名 {}
```
- 特点：
  - 接口不能实例化
  - 那么，接口如何实例化呢?
    - 按照多态的方式，由具体的实现类实例化。其实这也是多态的一种，接口多态。
  - 接口的实现类
    - 要么是抽象类
    - 要么重写接口中的所有抽象方法

案例代码八接口的概述以及练习【8.a 技能接口】

package com.groupies.base.day08;


public interface Demo8InterfaceSkills {
    //抽象方法
    public abstract void jump();
}

案例代码八接口的概述以及练习【8.b 猫类实现技能接口的跳方法】

package com.groupies.base.day08;


public class Demo8implementCat implements Demo8InterfaceSkills {

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

案例代码八接口的概述以及练习【8.c 狗类实现技能接口的跳方法】

package com.groupies.base.day08;


public abstract class Demo8implementDog implements Demo8InterfaceSkills {

}

案例代码八接口的概述以及练习【8.d 猫类和狗类的测试类】

package com.groupies.base.day08;


public class Demo8 {
    public static void main(String[] args) {
        //C:接口不能实例化
        //Demo8InterfaceJumpping j = new Demo8InterfaceJumpping();

        //c1:参照多态的形式使用实现类来实例化。
        Demo8InterfaceSkills jumpping = new Demo8implementCat();
        jumpping.jump();//猫可以跳高了
    }
}

3.1 接口的成员特点

成员变量
- 只能是常量
- 默认修饰符 public static final
构造方法
- 没有，因为接口主要是扩展功能的，而没有具体存在
成员方法
- 只能是抽象方法
- 默认修饰符 public abstract

案例代码九接口的概述以及练习【9.a 接口类】

package com.groupies.base.day08;


public interface Demo9Interface {
    public int num1 = 10;
    public final int num2 = 20;
    public static final int num3 = 30;

    
    //public Demo9Interface() {}

    
    //public void show() {}

    
    public abstract void method();
}

案例代码九接口的概述以及练习【9.b 实体类实现接口类】

package com.groupies.base.day08;


public class Demo9Implement implements Demo9Interface {

    public Demo9Implement() {
        super();
    }

    @Override
    public void method() {

    }
}

案例代码九接口的概述以及练习【9.c 实体类的测试类】

package com.groupies.base.day08;


public class Demo9 {
    public static void main(String[] args) {
        //按照多态的形式创建接口对象
        Demo9Implement i = new Demo9Implement();

        //Demo9Interface.num1 = 30;//java: 无法为最终变量num1分配值
        //System.out.println(i.num);

        //i.num2 = 40;//java: 无法为最终变量num2分配值
        //System.out.println(i.num2);

        System.out.println(Demo9Implement.num1);//10
        System.out.println(Demo9Implement.num2);//20
    }
}

3.2 类与类_类与接口_接口与接口的关系

类与类
- 继承关系，只能单继承，但是可以多层继承
类与接口
- 实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
接口与接口
- 继承关系，可以单继承，也可以多继承

案例代码十类与类_类与接口_接口与接口的关系【10.a 父类接口1】

package com.groupies.base.day08;


public interface Demo10InterfaceFather {
}

案例代码十类与类_类与接口_接口与接口的关系【10.b 父类接口2】

package com.groupies.base.day08;


public interface Demo10InterfaceMother {
}

案例代码十类与类_类与接口_接口与接口的关系【10.c 实体类–实现多个接口】

package com.groupies.base.day08;


public class Demo10POJOSon extends Object implements Demo10InterfaceFather,Demo10InterfaceMother{

}

案例代码十类与类_类与接口_接口与接口的关系【10.d 实体类–类多层继承】

package com.groupies.base.day08;


public class Demo10POJOSister extends Demo10POJOSon implements Demo10InterfaceFather, Demo10InterfaceMother {
}

案例代码十类与类_类与接口_接口与接口的关系【10.e 测试类】

package com.groupies.base.day08;


public class Demo10 {
    public static void main(String[] args) {

        //实例化对象
        Demo10POJOSister sister = new Demo10POJOSister();

        //c1:参照多态的形式使用实现类来实例化。
        Demo10InterfaceFather son = new Demo10POJOSon();
    }
}

3.3 抽象类与接口的区别

A:成员区别
- 抽象类：
  - 成员变量：可以是变量，也可以是常量
  - 构造方法：有构造方法
  - 成员方法：可以是抽象方法，也可以是非抽象方法
- 接口：
  - 成员变量：只能是常量
  - 构造方法：没有构造方法
  - 成员方法：只能是抽象方法
B:关系区别
- 类与类：继承关系，只能单继承，可以多层继承
- 类与接口：实现关系，可以单实现，也可以多实现
- 接口与接口：继承关系，可以单继承，也可以多继承
C:设计理念的区别
- 抽象类被继承体现的是："is a"抽象类中定义的是继承体系的共性功能
- 接口被实现体现的是：“like a” 接口中定义的是该体系的扩展功能
举例：
- 猫，动物
- 猫，跳高运动员

3.4 接口的练习

3.4.1 接口的练习之猫狗案例

案例代码十一接口的练习之猫狗案例【11.a 动物抽象类】

package com.groupies.base.day08;



public abstract class Demo11AbstractAnimal {
    private String name;
    private int age;

    public Demo11AbstractAnimal() {
    }

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

案例代码十一接口的练习之猫狗案例【11.b 技能接口】

package com.groupies.base.day08;


public interface Demo11InterfaceSkills {
    public abstract void jump();
}

案例代码十一接口的练习之猫狗案例【11.c 动物抽象类子类–猫类实现技能接口】

package com.groupies.base.day08;


public class Demo11POJOCat extends Demo11AbstractAnimal implements Demo11InterfaceSkills {
    public Demo11POJOCat() {
    }

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

    @Override
    public void eat() {
        System.out.println("【name:" + super.getName() + "】、【age：" + super.getAge() + "】猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("【name:" + super.getName() + "】、【age：" + super.getAge() + "】猫学会跳高了");
    }
}

案例代码十一接口的练习之猫狗案例【11.d 猫类的测试类】

package com.groupies.base.day08;


public class Demo11 {
    public static void main(String[] args) {
        Demo11POJOCat cat1 = new Demo11POJOCat();
        cat1.setName("加菲猫");
        cat1.setAge(3);
        System.out.println(cat1.getName() + "---" + cat1.getAge());//加菲猫---3
        cat1.eat();//【name:加菲猫】、【age：3】猫吃鱼
        cat1.jump();//【name:加菲猫】、【age：3】猫学会跳高了

        System.out.println("-------------------------");

        Demo11POJOCat cat2 = new Demo11POJOCat("美短", 2);
        System.out.println(cat2.getName() + "---" + cat2.getAge());
        cat2.eat();//【name:美短】、【age：2】猫吃鱼
        cat2.jump();//【name:美短】、【age：2】猫学会跳高了
    }
}

3.4.2 接口的练习之运动员和教练案例

案例分析

案例代码十二接口的练习之运动员和教练案例【12.a 人类抽象类】

package com.groupies.base.day08;


public abstract class Demo12AbstractPerson {
    private String name;
    private int age;

    public Demo12AbstractPerson() {
    }

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

案例代码十二接口的练习之运动员和教练案例【12.a.1 人类抽象类子类–教练类】

package com.groupies.base.day08;


public abstract class Demo12AbstractCoach extends Demo12AbstractPerson{
    public Demo12AbstractCoach() {}

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

    public abstract void teach();
}

案例代码十二接口的练习之运动员和教练案例【12.a.2 人类抽象类子类–运动员类】

package com.groupies.base.day08;


public abstract class Demo12AbstractPlayer extends Demo12AbstractPerson{
    public Demo12AbstractPlayer() {}

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

    public abstract void study();
}

案例代码十二接口的练习之运动员和教练案例【12.b 技能接口】

package com.groupies.base.day08;


public interface Demo12InterfaceSkills {
    public abstract void speakEnglish();
}

案例代码十二接口的练习之运动员和教练案例【12.c 教练类子类–篮球教练类】

package com.groupies.base.day08;


public class Demo12POJOBasketballCoach extends Demo12AbstractCoach {
    
    public Demo12POJOBasketballCoach() {
    }

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

    @Override
    
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }

    @Override
    
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
}

案例代码十二接口的练习之运动员和教练案例【12.d 教练类子类–乒乓球教练类–实现技能接口】

package com.groupies.base.day08;


public class Demo12POJOPingPangCoach extends Demo12AbstractCoach implements Demo12InterfaceSkills {

    
    public Demo12POJOPingPangCoach() {
    }

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

    @Override
    
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }

    @Override
    
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }

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

案例代码十二接口的练习之运动员和教练案例【12.e 运动员子类–篮球运动员】

package com.groupies.base.day08;


public class Demo12POJOBasketballPlayer extends Demo12AbstractPlayer {
    
    public Demo12POJOBasketballPlayer() {
    }

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

    @Override
    
    public void eat() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }

    @Override
    
    public void study() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
}

案例代码十二接口的练习之运动员和教练案例【12.f 运动员子类–乒乓球运动员类–实现技能接口】

package com.groupies.base.day08;


public class Demo12POJOPingPangPlayer extends Demo12AbstractPlayer implements Demo12InterfaceSkills {

    
    public Demo12POJOPingPangPlayer() {
    }

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

    @Override
    
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }

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

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

案例代码十二接口的练习之运动员和教练案例【12.g 测试类】

package com.groupies.base.day08;


public class Demo12 {
    public static void main(String[] args) {
        //测试运动员 -- 乒乓球运动员
        Demo12POJOPingPangPlayer pingPangPlayer = new Demo12POJOPingPangPlayer();
        pingPangPlayer.setName("王浩");
        pingPangPlayer.setAge(33);
        System.out.println(pingPangPlayer.getName() + "---" + pingPangPlayer.getAge());//王浩---33
        pingPangPlayer.eat();//乒乓球运动员吃大白菜，喝小米粥
        pingPangPlayer.study();//乒乓球运动员学习如何发球和接球
        pingPangPlayer.speakEnglish();//乒乓球运动员说英语

        //测试运动员 -- 篮球运动员
        Demo12POJOBasketballPlayer basketballPlayer = new Demo12POJOBasketballPlayer();
        basketballPlayer.setName("姚明");
        basketballPlayer.setAge(35);
        System.out.println(basketballPlayer.getName() + "---" + basketballPlayer.getAge());//姚明---35
        basketballPlayer.eat();//篮球运动员学习如何运球和投篮
        basketballPlayer.study();//篮球运动员吃牛肉，喝牛奶

        //测试教练 -- 乒乓球教练
        Demo12POJOPingPangCoach pingPangCoach = new Demo12POJOPingPangCoach();
        pingPangCoach.setName("孔令辉");
        pingPangCoach.setAge(53);
        System.out.println(pingPangCoach.getName() + "---" + pingPangCoach.getAge());//孔令辉---53
        pingPangCoach.eat();//乒乓球教练吃小白菜，喝大米粥
        pingPangCoach.teach();//乒乓球教练教如何发球和接球
        pingPangCoach.speakEnglish();//乒乓球教练说英语

        //测试运动员 -- 篮球教练
        Demo12POJOBasketballCoach basketballCoach = new Demo12POJOBasketballCoach();
        basketballCoach.setName("杜峰");
        basketballCoach.setAge(41);
        System.out.println(basketballCoach.getName() + "---" + basketballCoach.getAge());//杜峰---41
        basketballCoach.eat();//篮球教练吃羊肉，喝羊奶
        basketballCoach.teach();//篮球教练教如何运球和投篮
    }
}

4.包 package

4.1 包的概述和注意事项

包的概述
- 概述：其实就是文件夹
- 作用：对类进行分类管理

包的划分

举例：
- 学生的增加，删除，修改，查询
- 老师的增加，删除，修改，查询
- 以及以后可能出现的其他的类的增加，删除，修改，查询
基本的划分：按照模块和功能分。
高级的划分：就业班做项目的时候你就能看到了。

实例

//方案1：按照功能分
    com.itheima.add
        AddStudent
        AddTeacher
    com.itheima.delete
        DeleteStudent
        DeleteTeacher
		...

//方案2：按照模块分
    com.itheima.student
        AddStudent
        DeleteStudent
        ...
    com.itheima.teacher
        AddTeacher
        DeleteTeacher

定义包的格式

package 包名
//如果是多级包，用 . 隔开即可

注意事项
- package语句必须是程序的第一条可执行的代码
- package语句在一个java文件中只能有一个

4.2 导包的格式及使用

导包概述
- 不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
- 在IDEA中已经实现自动导包的功能了，不需要手动输入import进行导包
导包格式
- ```
import 包名;
```

案例代码十三导包的格式及使用【13.a 当前包下实体类】

package com.groupies.base.day08;


public class Demo13POJOStudent {
    public void show() {
        System.out.println("show");
    }
}

案例代码十三导包的格式及使用【13.b 其他包下实体类】

package com.itheima.day08;


public class Demo13Teacher {
    public void method() {
        System.out.println("method");
    }
}

案例代码十三导包的格式及使用【13.c 导包测试类】

package com.groupies.base.day08;

//使用其他包下的类需要使用import进行导包
import com.itheima.day08.Demo13Teacher;


public class Demo13 {
    public static void main(String[] args) {
        Demo13POJOStudent s = new Demo13POJOStudent();
        s.show();

        //类不在同一个包下，使用的时候，要加类的全路径名称
        com.itheima.day08.Demo13Teacher t1 = new com.itheima.day08.Demo13Teacher();

        //这样做太麻烦了，java就提供了一个导包的功能 import com.itheima.day08.Demo13Teacher;
        Demo13Teacher t2 = new Demo13Teacher();
        t2.method();
    }
}

4.3 四种权限修饰符的概述和访问特点

	a.本类	b.同一个包下(子类和无关类)	c.不同包下(子类)	d.不同包下(无关类)
private	√
默认（什么都不加)	√	√
protected	√	√	√
public	√	√	√	√

归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
- A:要想仅能在本类中访问使用private修饰
- B:要想本包中的类都可以访问除了private修饰符,其它都可以
- C:要想本包中的类与其他包中的子类可以访问使用protected修饰
- D:要想所有包中的所有类都可以访问使用public修饰。

案例代码十四四种权限修饰符的概述和访问特点【14.a 本类】

package com.groupies.base.day08;


public class Demo14POJOFather {
    private void show1() {
        System.out.println("show1");
    }

    void show2() {
        System.out.println("show2");
    }

    protected void show3() {
        System.out.println("show3");
    }

    public void show4() {
        System.out.println("show4");
    }

    public static void main(String[] args) {
        Demo14POJOFather f = new Demo14POJOFather();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

案例代码十四四种权限修饰符的概述和访问特点【14.b.1 同一个包下(子类)】

package com.groupies.base.day08;


public class Demo14POJOExtendSon extends Demo14POJOFather {
    public static void main(String[] args) {
        Demo14POJOFather f = new Demo14POJOFather();
        //f.show1(); 同一个包下(子类) 不能访问对象private修饰的方法
        f.show2();
        f.show3();
        f.show4();
    }
}

案例代码十四四种权限修饰符的概述和访问特点【14.b 同一个包下(无关类)】

package com.groupies.base.day08;


public class Demo14 {
    public static void main(String[] args) {
        Demo14POJOFather f = new Demo14POJOFather();
        //f.show1(); //同一个包下(无关类) 不能访问对象private修饰的方法
        f.show2();
        f.show3();
        f.show4();
    }
}

案例代码十四四种权限修饰符的概述和访问特点【14.c 不同包下(子类)】

package com.itheima.day08;

import com.groupies.base.day08.Demo14POJOFather;


public class Demo14POJOExtendSon extends Demo14POJOFather {
    public static void main(String[] args) {
        Demo14POJOFather f = new Demo14POJOFather();
        //f.show1(); //不同包下(子类中父类对象) 不能访问对象private修饰的方法
        //f.show2(); //不同包下(子类中父类对象) 不能访问对象默认的方法
        //f.show3();//不同包下(子类中父类对象) 不能访问对象protected修饰的方法
        f.show4();


        Demo14POJOExtendSon s = new Demo14POJOExtendSon();
        //s.show1(); //不同包下(子类) 不能访问对象private修饰的方法
        //s.show2(); //不同包下(子类) 不能访问对象默认的方法
        s.show3();
        s.show4();
    }
}

案例代码十四四种权限修饰符的概述和访问特点【14.d 不同包下(无关类)】

package com.itheima.day08;

import com.groupies.base.day08.Demo14POJOFather;


public class Demo14 {
    public static void main(String[] args) {
        Demo14POJOFather f = new Demo14POJOFather();
        //f.show1(); //不同包下(无关类) 不能访问对象private修饰的方法
        //f.show2(); //不同包下(无关类) 不能访问对象默认的方法
        //f.show3();//不同包下(无关类) 不能访问对象protected修饰的方法
        f.show4();
    }
}

5.课后练习

5.1 练习1 经理、程序员

练习1 经理、程序员【1.a 员工抽象类】

package com.groupies.base.day08;


public abstract class HomeWork1AbstractStaff {
    //姓名
    private String name;
    //工号
    private String ID;
    //工资
    private double salary;

    
    public HomeWork1AbstractStaff() {
    }

    
    public HomeWork1AbstractStaff(String name, String ID, double salary) {
        this.name = name;
        this.ID = ID;
        this.salary = salary;
    }

    
    public String getName() {
        return name;
    }

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

    
    public String getID() {
        return ID;
    }

    
    public void setID(String ID) {
        this.ID = ID;
    }

    
    public double getSalary() {
        return salary;
    }

    
    public void setSalary(double salary) {
        this.salary = salary;
    }

    
    public abstract void work();
}

练习1 经理、程序员【1.a.1 员工抽象类子类–经理类】

package com.groupies.base.day08;


public class HomeWork1ExtendManager extends HomeWork1AbstractStaff {
    //奖金
    private double bonus;

    
    public HomeWork1ExtendManager() {
    }

    
    public HomeWork1ExtendManager(String name, String ID, double salary, double bonus) {
        super(name, ID, salary);
        this.bonus = bonus;
    }

    
    public double getBonus() {
        return bonus;
    }

    
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    
    public void work() {
        System.out.println("【name:" + this.getName() + "】 【ID:" + this.getID() + "】 【salary:" + this.getSalary() + "】 【bonus:" + this.getBonus() + "】 项目经理的工作是看着程序员敲代码");
    }
}

练习1 经理、程序员【1.a.1 员工抽象类子类–程序员类】

package com.groupies.base.day08;


public class HomeWork1ExtendProgrammer extends HomeWork1AbstractStaff {
    
    public HomeWork1ExtendProgrammer() {
    }

    
    public HomeWork1ExtendProgrammer(String name, String ID, double salary) {
        super(name, ID, salary);
    }

    @Override
    
    public void work() {
        System.out.println("【name:" + this.getName() + "】 【ID:" + this.getID() + "】 【salary:" + this.getSalary() + "】 程序员的工作是敲代码");

    }
}

练习1 经理、程序员【1.b 员工类的测试类】

package com.groupies.base.day08;


public class HomeWork1 {
    
    public static void main(String[] args) {
        HomeWork1ExtendManager manager = new HomeWork1ExtendManager("林青霞", "A0001", 654.32, 789.12);
        manager.work();//【name:林青霞】 【ID:A0001】 【salary:654.32】 【bonus:789.12】 项目经理的工作是看着程序员敲代码

        HomeWork1ExtendProgrammer programmer = new HomeWork1ExtendProgrammer("李四", "110", 22000);
        programmer.work();//【name:李四】 【ID:110】 【salary:22000.0】 程序员的工作是敲代码
    }
}

5.2 练习2 抽象动物、犬类、缉毒犬类、技能接口

练习2 抽象动物、犬类、缉毒犬类、技能接口【2.a 技能接口】

package com.groupies.base.day08;


interface HomeWork2InterfaceSkills {
    
    public abstract void jiDu();
}

练习2 抽象动物、犬类、缉毒犬类、技能接口【2.b 动物抽象类】

package com.groupies.base.day08;


abstract class HomeWork2AbstractAnimal {
    
    public HomeWork2AbstractAnimal() {
    }

    
    public abstract void call();

    
    public abstract void eat();
}

练习2 抽象动物、犬类、缉毒犬类、技能接口【2.b.1 动物抽象类子类–犬类】

package com.groupies.base.day08;


abstract class HomeWork2ExtendDog extends HomeWork2AbstractAnimal {
    
    public HomeWork2ExtendDog() {
    }

}

练习2 抽象动物、犬类、缉毒犬类、技能接口【2.b.1 动物抽象类子类–犬类子类–缉毒犬类】

package com.groupies.base.day08;


class HomeWork2ExtendJDDog extends HomeWork2ExtendDog implements HomeWork2InterfaceSkills {
    
    public HomeWork2ExtendJDDog() {
    }

    @Override
    
    public void call() {
        System.out.println("汪汪叫");
    }

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

    @Override
    
    public void jiDu() {
        System.out.println("用鼻子缉毒");
    }

}

练习2 抽象动物、犬类、缉毒犬类、技能接口【2.c 缉毒犬类的测试类】

package com.groupies.base.day08;


public class HomeWork2 {
    
    public static void main(String[] args) {
        HomeWork2ExtendJDDog dog = new HomeWork2ExtendJDDog();
        dog.call();//汪汪叫
        dog.eat();//狗啃骨头
        dog.jiDu();//用鼻子缉毒
    }
}

5.3 练习3 新旧手机、手机行为接口

练习3 新旧手机、手机行为接口【3.a 手机行为接口】

package com.groupies.base.day08;


public interface HomeWork3IPlay {
    
    public abstract void playGame();
}

练习3 新旧手机、手机行为接口【3.b 手机类】

package com.groupies.base.day08;


public class HomeWork3POJOPhone implements HomeWork3IPlay {
    
    public HomeWork3POJOPhone() {
    }

    
    public void call() {
        System.out.println("打电话");
    }

    
    public void message() {
        System.out.println("发短信");
    }

    @Override
    
    public void playGame() {
        System.out.println("用新手机玩游戏");
    }
}

练习3 新旧手机、手机行为接口【3.b.1 手机类子类–旧手机类】

package com.groupies.base.day08;


public class HomeWork3ExtendOldPhone extends HomeWork3POJOPhone {
}

练习3 新旧手机、手机行为接口【3.a 手机类的测试类】

package com.groupies.base.day08;


public class HomeWork3 {
    public static void main(String[] args) {
        //打电话
        //发短信
        usePhone(new HomeWork3ExtendOldPhone());
        System.out.println("----------");
        //打电话
        //发短信
        //用新手机玩游戏
        usePhone(new HomeWork3POJOPhone());
    }

    
    public static void usePhone(HomeWork3POJOPhone p) { // Phone p = new OldPhone();
        if (p instanceof HomeWork3ExtendOldPhone) {
            HomeWork3ExtendOldPhone old = (HomeWork3ExtendOldPhone) p;
            old.call();
            old.message();
        } else if (p instanceof HomeWork3POJOPhone) {
            HomeWork3POJOPhone newPhone = (HomeWork3POJOPhone) p;
            newPhone.call();
            newPhone.message();
            newPhone.playGame();
        } else {
            p.call();
            p.message();
        }
    }
}

5.4 主人、动物抽象、猫、狗、instanceof

练习4 主人、抽象动物、猫、狗【4.a 动物抽象类】

package com.groupies.base.day08;


public abstract class HomeWork4AbstractAnimal {
    private String color;
    private int age;

    
    public HomeWork4AbstractAnimal() {
    }

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

    
    public String getColor() {
        return color;
    }

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

    
    public int getAge() {
        return age;
    }

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

    
    public abstract void eat(String something);
}

练习4 主人、抽象动物、猫、狗【4.a.1 动物抽象类子类–猫类】

package com.groupies.base.day08;


public class HomeWork4ExtendCat extends HomeWork4AbstractAnimal {
    
    public HomeWork4ExtendCat() {
    }

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

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

    
    public void catchMouse() {
        System.out.println("逮老鼠");
    }
}

练习4 主人、抽象动物、猫、狗【4.a.2 动物抽象类子类–狗类】

package com.groupies.base.day08;


public class HomeWork4ExtendDog extends HomeWork4AbstractAnimal {

    
    public HomeWork4ExtendDog() {
    }

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

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

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

}

练习4 主人、抽象动物、猫、狗【4.b 主人类】

package com.groupies.base.day08;


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

    
    public HomeWork4POJOPerson() {
    }

    
    public HomeWork4POJOPerson(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 void keepPet(HomeWork4AbstractAnimal a, String something) {
        // instanceof 实例，判断对象类型
        if (a instanceof HomeWork4ExtendDog) {
            HomeWork4ExtendDog dog = (HomeWork4ExtendDog) a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "的" + dog.getAge() + "岁的宠物");
            dog.eat(something);
        } else if (a instanceof HomeWork4ExtendCat) {
            HomeWork4ExtendCat cat = (HomeWork4ExtendCat) a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "的" + cat.getAge() + "岁的宠物");
            cat.eat(something);
        }
    }
}

练习4 主人、抽象动物、猫、狗【4.c 测试类】

package com.groupies.base.day08;


public class HomeWork4 {
    public static void main(String[] args) {
        HomeWork4ExtendCat c = new HomeWork4ExtendCat("灰色", 3);
        HomeWork4POJOPerson pc = new HomeWork4POJOPerson("老王", 30);
        
        pc.keepPet(c, "鱼");

        System.out.println("----");

        HomeWork4ExtendDog d = new HomeWork4ExtendDog("黑颜色", 3);
        HomeWork4POJOPerson pd = new HomeWork4POJOPerson("老李", 25);
        
        pd.keepPet(d, "骨头");
    }
}

21/03/25

3.1

.Net相关栏目本月热门文章