JAVA基础知识

day01-继承&修饰符

1. 继承

1.1 继承的实现（把握）

• 继承的概念
  

* 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

• 实现继承的格式
  

* 继承通过extends实现
* 格式：class 子类 extends 父类 { }
* 举例：class Dog extends Animal { }

• 继承带来的好处
  

* 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

• 示例代码
  

```java
public class Fu {
public void show() {
System.out.println("show方法被调用");
}
}
public class Zi extends Fu {
public void method() {
System.out.println("method方法被调用");
}
}
public class Demo {
public static void main(String[] args) {
//创建对象，调用方法
Fu f = new Fu();
f.show();
Zi z = new Zi();
z.method();
z.show();
}
}
```
1.2 继承的好处和弊端（明白）

• 继承好处
  

* 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
* 提高了代码的维护性(如果方法的代码须要修改，修改一处即可)

• 继承弊端
  

* 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变革时子类实现也不得不跟着变革，减弱了子类的独立性

• 继承的应用场景：
  

* 使用继承，须要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
*  is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
2. 继承中的成员访问特点

2.1 继承中变量的访问特点（把握）

在子类方法中访问一个变量，采用的是就近原则。

• 子类局部范围找
  
• 子类成员范围找
  
• 父类成员范围找
  
• 如果都没有就报错(不考虑父亲的父亲…)
  

• 示例代码
  

```java
class Fu {
int num = 10;
}
class Zi {
int num = 20;
public void show(){
int num = 30;
System.out.println(num);
}
}
public class Demo1 {
public static void main(String[] args) {
Zi z = new Zi();
z.show(); // 输出show方法中的局部变量30
}
}
```
2.2 super（把握）

• this&super关键字：
  

* this：代表本类对象的引用
* super：代表父类存储空间的标识(可以明白为父类对象引用)

• this和super的使用分别
  

* 成员变量：
* this.成员变量    -   访问本类成员变量
* super.成员变量 -   访问父类成员变量
* 成员方法：
* this.成员方法  - 访问本类成员方法
* super.成员方法 - 访问父类成员方法

• 构造方法：
  

* this(…)  -  访问本类构造方法
* super(…)  -  访问父类构造方法
2.3 继承中构造方法的访问特点（明白）

留意：子类中全部的构造方法默认都会访问父类中无参的构造方法
​ 子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，肯定要先完成父类数据的初始化，缘故因由在于，每一个子类构造方法的第一条语句默认都是：super()
问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 在父类中自己提供一个无参构造方法
保举方案：
​ 自己给出无参构造方法
2.4 继承中成员方法的访问特点（把握）

通过子类对象访问一个方法

• 子类成员范围找
  
• 父类成员范围找
  
• 如果都没有就报错(不考虑父亲的父亲…)
  

2.5 super内存图（明白）

• 对象在堆内存中，会单独存在一块super区域，用来存放父类的数据
  

2.6 方法重写（把握）

• 1、方法重写概念
  

* 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

• 2、方法重写的应用场景
  

* 当子类须要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，如许，即相沿了父类的功能，又定义了子类特有的内容

• 3、Override注解
  

* 用来检测当前的方法，是否是重写的方法，起到【校验】的作用
2.7 方法重写的留意事项（把握）

• 方法重写的留意事项
  

• 私有方法不能被重写(父类私有成员子类是不能继承的)
  
• 子类方法访问权限不能更低(public > 默认 > 私有)
  

• 示例代码
  

1. public class Fu {
3.     private void show() {
5.         System.out.println("Fu中show()方法被调用");
7.     }
9.   
11.     void method() {
13.         System.out.println("Fu中method()方法被调用");
15.     }
17. }
19.   
21. public class Zi extends Fu {
23.   
25.     /* 编译【出错】，子类不能重写父类私有的方法*/
27.     @Override
29.     private void show() {
31.         System.out.println("Zi中show()方法被调用");
33.     }
35.     /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
37.     @Override
39.     private void method() {
41.         System.out.println("Zi中method()方法被调用");
43.     }
45.   
47.     /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
49.     @Override
51.     public void method() {
53.         System.out.println("Zi中method()方法被调用");
55.     }
57. }

复制代码

2.8. Java中继承的留意事项（把握）

• Java中继承的留意事项
  

1. Java中类只支持单继承，不支持多继承
* 错误范例：class A extends B, C { }
2. Java中类支持多层继承

• 多层继承示例代码：
  

```java
public class Granddad {
public void drink() {
System.out.println("爷爷爱喝酒");
}
}
public class Father extends Granddad {
public void smoke() {
System.out.println("爸爸爱抽烟");
}
}
public class Mother {
public void dance() {
System.out.println("妈妈爱舞蹈");
}
}
public class Son extends Father {
// 此时，Son类中就同时拥有drink方法以及smoke方法
}
```
3. 继承练习

3.1 老师和学生（应用）

• 需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试
  
• 步调：
  

①定义老师类(姓名，年龄，教书())
②定义学生类(姓名，年龄，学习())
③定义测试类，写代码测试
④共性抽取父类，定义人类(姓名，年龄)
⑤定义老师类，继承人类，并给出自己特有方法：教书()
⑥定义学生类，继承人类，并给出自己特有方法：学习()
⑦定义测试类，写代码测试

• 示例代码：
  

```java
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;
}
}
class Teacher extends Person {
public Teacher() {}
public Teacher(String name,int age) {
super(name,age);
}
public void teach() {
System.out.println("用爱成就每一位学员");
}
}
class Student extends Person{
public Student() {}
public Student(String name, int age) {
super(name,age);
}
public void study(){
System.out.println("学生学习");
}
}
class PersonDemo {
public static void main(String[] args){
//创建老师类对象并进行测试
Teacher t1 = new Teacher();
t1.setName("林青霞");
t1.setAge(30);
System.out.println(t1.getName() + "," + t1.getAge());
t1.teach();
Teacher t2 = new Teacher("风清扬", 33);
System.out.println(t2.getName() + "," + t2.getAge());
t2.teach();
// 创建学生类对象测试
Student s = new Student("张三"，23)；
System.out.println(s.getName() + "," + s.getAge());
s.study();
}
}
```
3.2 猫和狗（ 应用）

• 需求：请采用继承的头脑实现猫和狗的案例，并在测试类中进行测试
  
• 分析：
  

①猫：
​ 成员变量：姓名，年龄
​ 构造方法：无参，带参
​ 成员方法：get/set方法，抓老鼠()
②狗：
​ 成员变量：姓名，年龄
​ 构造方法：无参，带参
​ 成员方法：get/set方法，看门()
③共性：
​ 成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法

• 步调：
  

1、定义动物类(Animal)
​ 【成员变量：姓名，年龄】【 构造方法：无参，带参】【成员方法：get/set方法】
2、定义猫类(Cat)，继承动物类
​ 【构造方法：无参，带参】【成员方法：抓老鼠() 】
3、定义狗类(Dog)，继承动物类
​ 【构造方法：无参，带参】【成员方法：看门() 】
4、定义测试类(AnimalDemo)，写代码测试

• 示例代码：
  

```java
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;
}
}
class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
class Dog extends Animal {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
public void lookDoor() {
System.out.println("狗看门");
}
}
/*
测试类
*/
public class AnimalDemo {
public static void main(String[] args) {
//创建猫类对象并进行测试
Cat c1 = new Cat();
c1.setName("加菲猫");
c1.setAge(5);
System.out.println(c1.getName() + "," + c1.getAge());
c1.catchMouse();
Cat c2 = new Cat("加菲猫", 5);
System.out.println(c2.getName() + "," + c2.getAge());
c2.catchMouse();
}
}
```
4. 修饰符

4.1 package（相识）

• 1、包的概念
  

* 包就是文件夹，用来管理类文件的

• 2、包的定义格式
  

* package 包名; (多级包用.分开)
* 例如：package com.heima.demo;

• 3、带包编译&带包运行
  

* 带包编译：javac –d . 类名.java
* 例如：javac  -d  . com.heima.demo.HelloWorld.java
* 带包运行：java 包名+类名
* 例如：java com.heima.demo.HelloWorld
4.2 import（明白）

• 导包的意义
  

使用不同包下的类时，使用的时间要写类的全路径，写起来太麻烦了
为了简化带包的操作，Java就提供了导包的功能

• 导包的格式
  

格式：import 包名;
范例：import java.util.Scanner;

• 示例代码（没有使用导包，创建的Scanner对象）
  

1. package com.heima;
3.   
5. public class Demo {
7.     public static void main(String[] args) {
9.         // 1. 没有导包，创建Scnaner对象
11.         java.util.Scanner sc = new java.util.Scanner(System.in);
13.     }
15. }

复制代码

• 示例代码（使用导包后，创建的Scanner对象）
  

1. package com.heima;
3.   
5. import java.util.Scanner;
7.   
9. public class Demo {
11.     public static void main(String[] args) {
13.         // 1. 没有导包，创建Scnaner对象
15.         Scanner sc = new Scanner(System.in);
17.     }
19. }

复制代码

4.3 权限修饰符（明白）

.png)
4.4 final（应用）

• fianl关键字的作用
  

* final代表最终的意思，可以修饰成员方法，成员变量，类

• final修饰类、方法、变量的效果
  

* fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
* final修饰方法：该方法不能被重写
* final修饰变量：表明该变量是一个常量，不能再次赋值
4.5 final修饰局部变量（明白）

• fianl修饰基本数据范例变量
  

* final 修饰指的是基本范例的数据值不能发生改变

• final修饰引用数据范例变量
  

* final 修饰指的是引用范例的地址值不能发生改变，但是地址里面的内容是可以发生改变的
* 举例：
```java
public static void main(String[] args){
final Student s = new Student(23);
s = new Student(24);  // 错误
s.setAge(24);  // 正确
}
```
4.6 static（应用）

• static的概念
  

* static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

• static修饰的特点
  

1. 被类的全部对象共享，这也是我们判定是否使用静态关键字的条件
2. 可以通过类名调用固然，也可以通过对象名调用【保举使用类名调用】

• 示例代码：
  

1. class Student {
3.   
5.     public String name; //姓名
7.     public int age; //年龄
9.     public static String university; //学校 共享数据！所以设计为静态！
11.   
13.     public void show() {
15.         System.out.println(name + "," + age + "," + university);
17.     }
19.   
21. }
23.   
25. public class StaticDemo {
27.     public static void main(String[] args) {
29.       // 为对象的共享数据赋值
31.         Student.university = "传智大学";
33.   
35.         Student s1 = new Student();
37.         s1.name = "林青霞";
39.         s1.age = 30;
41.         s1.show();
43.   
45.         Student s2 = new Student();
47.         s2.name = "风清扬";
49.         s2.age = 33;
51.         s2.show();
53.     }
55. }

复制代码

4.7 static访问特点（把握）

• static的访问特点
  

* 非静态的成员方法
* 能访问静态的成员变量
* 能访问非静态的成员变量
* 能访问静态的成员方法
* 能访问非静态的成员方法
* 静态的成员方法
* 能访问静态的成员变量
* 能访问静态的成员方法
* 总结成一句话就是：
* 静态成员方法只能访问静态成员
day02-多态&抽象类&接口

1.多态

1.1多态的概述（记忆）

• 什么是多态
  

​ 同一个对象，在不同时刻体现出来的不同形态

• 多态的前提
  

- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象
1.2多态中的成员访问特点（记忆）

• 成员访问特点
  

- 成员变量
​   编译看父类，运行看父类
- 成员方法
​   编译看父类，运行看子类

• 代码演示
  

- 动物类
```java
public class Animal {
public int age = 40;
public void eat() {
System.out.println("动物吃东西");
}
}
```
- 猫类
```java
public class Cat extends Animal {
public int age = 20;
public int weight = 10;
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
```
- 测试类
```java
public class AnimalDemo {
public static void main(String[] args) {
//有父类引用指向子类对象
Animal a = new Cat();
System.out.println(a.age);
//        System.out.println(a.weight);
a.eat();
//        a.playGame();
}
}
```
1.3多态的好处和弊端（记忆）

• 好处
  

​ 提高程序的扩展性。定义方法时间，使用父范例作为参数，在使用的时间，使用具体的子范例参与操作

• 弊端
  

​ 不能使用子类的特有成员
1.4多态中的转型（应用）

• 向上转型
  

​ 父类引用指向子类对象就是向上转型

• 向下转型
  

​ 格式：子范例 对象名 = (子范例)父类引用;

• 代码演示
  

- 动物类
```java
public class Animal {
public void eat() {
System.out.println("动物吃东西");
}
}
```
- 猫类
```java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
```
- 测试类
```java
public class AnimalDemo {
public static void main(String[] args) {
//多态
//向上转型
Animal a = new Cat();
a.eat();
//      a.playGame();
//向下转型
Cat c = (Cat)a;
c.eat();
c.playGame();
}
}
```
1.5多态的案例（应用）

• 案例需求
  

​ 请采用多态的头脑实现猫和狗的案例，并在测试类中进行测试

• 代码实现
  

- 动物类
```java
public 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 void eat() {
System.out.println("动物吃东西");
}
}
```
- 猫类
```java
public class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
```
- 狗类
```java
public class Dog extends Animal {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
```
- 测试类
```java
public class AnimalDemo {
public static void main(String[] args) {
//创建猫类对象进行测试
Animal a = new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName() + "," + a.getAge());
a.eat();
a = new Cat("加菲", 5);
System.out.println(a.getName() + "," + a.getAge());
a.eat();
}
}
```
2.抽象类

2.1抽象类的概述（明白）

​   当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时间就须要抽象类了！
​   在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！
2.2抽象类的特点（记忆）

• 抽象类和抽象方法必须使用 abstract 关键字修饰
  

```java
//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();
```

• 抽象类中不肯定有抽象方法，有抽象方法的类肯定是抽象类
  
• 抽象类不能实例化
  

​ 抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

• 抽象类的子类
  

​ 要么重写抽象类中的全部抽象方法
​ 要么是抽象类
2.3抽象类的成员特点（记忆）

• 成员的特点
  

- 成员变量
- 既可以是变量
- 也可以是常量
- 构造方法
- 空参构造
- 有参构造
- 成员方法
- 抽象方法
- 平凡方法

• 代码演示
  

- 动物类
```java
public abstract class Animal {
private int age = 20;
private final String city = "北京";
public Animal() {}
public Animal(int age) {
this.age = age;
}
public void show() {
age = 40;
System.out.println(age);
//        city = "上海";
System.out.println(city);
}
public abstract void eat();
}
```
- 猫类
```java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
```
- 测试类
```java
public class AnimalDemo {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
a.show();
}
}
```
2.4抽象类的案例（应用）

• 案例需求
  

​ 请采用抽象类的头脑实现猫和狗的案例，并在测试类中进行测试

• 代码实现
  

- 动物类
```java
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();
}
```
- 猫类
```java
public class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
```
- 狗类
```java
public class Dog extends Animal {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
```
- 测试类
```java
public class AnimalDemo {
public static void main(String[] args) {
//创建对象，按照多态的方式
Animal a = new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
System.out.println("--------");
a = new Cat("加菲",5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
}
}
```
3.接口

3.1接口的概述（明白）

​   接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
​   Java中的接口更多的体现在对行为的抽象！
3.2接口的特点（记忆）

• 接口用关键字interface修饰
  

```java
public interface 接口名 {}
```

• 类实现接口用implements表示
  

```java
public class 类名 implements 接口名 {}
```

• 接口不能实例化
  

​ 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
​ 多态的情势：具体类多态，抽象类多态，接口多态。

• 接口的子类
  

​ 要么重写接口中的全部抽象方法
​ 要么子类也是抽象类
3.3接口的成员特点（记忆）

• 成员特点
  

- 成员变量
​    只能是常量
​    默认修饰符：public static final
- 构造方法
​   没有，因为接口主要是扩展功能的，而没有具体存在
- 成员方法
​   只能是抽象方法
​   默认修饰符：public abstract
​   关于接口中的方法，JDK8和JDK9中有一些新特性，背面再讲解

• 代码演示
  

- 接口
```java
public interface Inter {
public int num = 10;
public final int num2 = 20;
//    public static final int num3 = 30;
int num3 = 30;
//    public Inter() {}
//    public void show() {}
public abstract void method();
void show();
}
```
- 实现类
```java
public class InterImpl extends Object implements Inter {
public InterImpl() {
super();
}
@Override
public void method() {
System.out.println("method");
}
@Override
public void show() {
System.out.println("show");
}
}
```
- 测试类
```java
public class InterfaceDemo {
public static void main(String[] args) {
Inter i = new InterImpl();
//        i.num = 20;
System.out.println(i.num);
//        i.num2 = 40;
System.out.println(i.num2);
System.out.println(Inter.num);
}
}
```
3.4接口的案例（应用）

• 案例需求
  

​ 对猫和狗进行训练，他们就可以跳高了，这里参加跳高功能。
​ 请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。

• 代码实现
  

- 动物类
```java
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();
}
```
- 跳高接口
```java
public interface Jumpping {
public abstract void jump();
}
```
- 猫类
```java
public class Cat extends Animal implements Jumpping {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
```
- 测试类
```java
public class AnimalDemo {
public static void main(String[] args) {
//创建对象，调用方法
Jumpping j = new Cat();
j.jump();
System.out.println("--------");
Animal a = new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
//        a.jump();
a = new Cat("加菲",5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
System.out.println("--------");
Cat c = new Cat();
c.setName("加菲");
c.setAge(5);
System.out.println(c.getName()+","+c.getAge());
c.eat();
c.jump();
}
}
```
3.5类和接口的关系（记忆）

• 类与类的关系
  

​ 继承关系，只能单继承，但是可以多层继承

• 类与接口的关系
  

​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

• 接口与接口的关系
  

​ 继承关系，可以单继承，也可以多继承
3.6抽象类和接口的区别（记忆）

• 成员区别
  

- 抽象类
​   变量,常量；有构造方法；有抽象方法,也有非抽象方法
- 接口
​   常量；抽象方法

• 关系区别
  

- 类与类
​   继承，单继承
- 类与接口
​   实现，可以单实现，也可以多实现
- 接口与接口
​   继承，单继承，多继承

• 设计理念区别
  

- 抽象类
​   对类抽象，包罗属性、行为
- 接口
​   对行为抽象，主要是行为
4.综合案例

4.1案例需求（明白）

​   我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。
​   为了出国交流，跟乒乓球相关的人员都须要学习英语。
​   请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。

4.2代码实现（应用）

• 抽象人类
  

1. public abstract class Person {
3.     private String name;
5.     private int age;
7.   
9.     public Person() {
11.     }
13.   
15.     public Person(String name, int age) {
17.         this.name = name;
19.         this.age = age;
21.     }
23.   
25.     public String getName() {
27.         return name;
29.     }
31.   
33.     public void setName(String name) {
35.         this.name = name;
37.     }
39.   
41.     public int getAge() {
43.         return age;
45.     }
47.   
49.     public void setAge(int age) {
51.         this.age = age;
53.     }
55.   
57.     public abstract void eat();
59. }

复制代码

• 抽象运动员类
  

1. public abstract class Player extends Person {
3.     public Player() {
5.     }
7.   
9.     public Player(String name, int age) {
11.         super(name, age);
13.     }
15.   
17.     public abstract void study();
19. }

复制代码

• 抽象教练类
  

1. public abstract class Coach extends Person {
3.     public Coach() {
5.     }
7.   
9.     public Coach(String name, int age) {
11.         super(name, age);
13.     }
15.   
17.     public abstract void teach();
19. }

复制代码

• 学英语接口
  

1. public interface SpeakEnglish {
3.     public abstract void speak();
5. }

复制代码

• 蓝球教练
  

1. public class BasketballCoach extends Coach {
3.     public BasketballCoach() {
5.     }
7.   
9.     public BasketballCoach(String name, int age) {
11.         super(name, age);
13.     }
15.   
17.     @Override
19.     public void teach() {
21.         System.out.println("篮球教练教如何运球和投篮");
23.     }
25.   
27.     @Override
29.     public void eat() {
31.         System.out.println("篮球教练吃羊肉，喝羊奶");
33.     }
35. }

复制代码

• 乒乓球教练
  

1. public class PingPangCoach extends Coach implements SpeakEnglish {
3.   
5.     public PingPangCoach() {
7.     }
9.   
11.     public PingPangCoach(String name, int age) {
13.         super(name, age);
15.     }
17.   
19.     @Override
21.     public void teach() {
23.         System.out.println("乒乓球教练教如何发球和接球");
25.     }
27.   
29.     @Override
31.     public void eat() {
33.         System.out.println("乒乓球教练吃小白菜，喝大米粥");
35.     }
37.   
39.     @Override
41.     public void speak() {
43.         System.out.println("乒乓球教练说英语");
45.     }
47. }

复制代码

• 乒乓球运动员
  

1. public class PingPangPlayer extends Player implements SpeakEnglish {
3.   
5.     public PingPangPlayer() {
7.     }
9.   
11.     public PingPangPlayer(String name, int age) {
13.         super(name, age);
15.     }
17.   
19.     @Override
21.     public void study() {
23.         System.out.println("乒乓球运动员学习如何发球和接球");
25.     }
27.   
29.     @Override
31.     public void eat() {
33.         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
35.     }
37.   
39.     @Override
41.     public void speak() {
43.         System.out.println("乒乓球运动员说英语");
45.     }
47. }

复制代码

• 篮球运动员
  

1. public class BasketballPlayer extends Player {
3.   
5.     public BasketballPlayer() {
7.     }
9.   
11.     public BasketballPlayer(String name, int age) {
13.         super(name, age);
15.     }
17.   
19.     @Override
21.     public void study() {
23.         System.out.println("篮球运动员学习如何运球和投篮");
25.     }
27.   
29.     @Override
31.     public void eat() {
33.         System.out.println("篮球运动员吃牛肉，喝牛奶");
35.     }
37. }

复制代码

day03-内部类&API

1. 参数通报

1.1 类名作为形参和返回值（应用）

• 1、类名作为方法的形参
  

方法的形参是类名，实在须要的是该类的对象
实际通报的是该对象的【地址值】

• 2、类名作为方法的返回值
  

方法的返回值是类名，实在返回的是该类的对象
实际通报的，也是该对象的【地址值】

• 示例代码：
  

```java
class Cat {
public void eat() {
System.out.println("猫吃鱼");
}
}
class CatOperator {
public void useCat(Cat c) { //Cat c = new Cat();
c.eat();
}
public Cat getCat() {
Cat c = new Cat();
return c;
}
}
public class CatDemo {
public static void main(String[] args) {
//创建操作类对象，并调用方法
CatOperator co = new CatOperator();
Cat c = new Cat();
co.useCat(c);
Cat c2 = co.getCat(); //new Cat()
c2.eat();
}
}
```
1.2 抽象类作为形参和返回值（明白）

• 抽象类作为形参和返回值
  

* 方法的形参是抽象类名，实在须要的是该抽象类的子类对象
* 方法的返回值是抽象类名，实在返回的是该抽象类的子类对象

• 示例代码：
  

```java
abstract class Animal {
public abstract void eat();
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
class AnimalOperator {
public void useAnimal(Animal a) { //Animal a = new Cat();
a.eat();
}
public Animal getAnimal() {
Animal a = new Cat();
return a;
}
}
public class AnimalDemo {
public static void main(String[] args) {
//创建操作类对象，并调用方法
AnimalOperator ao = new AnimalOperator();
Animal a = new Cat();
ao.useAnimal(a);
Animal a2 = ao.getAnimal(); //new Cat()
a2.eat();
}
}
```
1.3 接口名作为形参和返回值（明白）

• 接口作为形参和返回值
  

* 方法的形参是接口名，实在须要的是该接口的实现类对象
* 方法的返回值是接口名，实在返回的是该接口的实现类对象

• 示例代码：
  

```java
interface Jumpping {
void jump();
}
class JumppingOperator {
public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
j.jump();
}
public Jumpping getJumpping() {
Jumpping j = new Cat();
return j;
}
}
class Cat implements Jumpping {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
public class JumppingDemo {
public static void main(String[] args) {
//创建操作类对象，并调用方法
JumppingOperator jo = new JumppingOperator();
Jumpping j = new Cat();
jo.useJumpping(j);
Jumpping j2 = jo.getJumpping(); //new Cat()
j2.jump();
}
}
```
2. 内部类

2.1 内部类的基本使用（明白）

• 内部类概念
  

* 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

• 内部类定义格式
  

* 格式&举例：
```java
/*
格式：
class 外部类名{
修饰符 class 内部类名{
}
}
*/
class Outer {
public class Inner {
}
}
```

• 内部类的访问特点
  

* 内部类可以直接访问外部类的成员，包罗私有
* 外部类要访问内部类的成员，必须创建对象

• 示例代码：
  

```java
/*
内部类访问特点：
内部类可以直接访问外部类的成员，包罗私有
外部类要访问内部类的成员，必须创建对象
*/
public class Outer {
private int num = 10;
public class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
```
2.2 成员内部类（明白）

• 成员内部类的定义位置
  

* 在类中方法，跟成员变量是一个位置

• 外界创建成员内部类格式
  

* 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
* 举例：Outer.Inner oi = new Outer().new Inner();

• 成员内部类的保举使用方案
  

* 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

• 示例代码：
  

```java
class Outer {
private int num = 10;
private class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
Outer o = new Outer();
o.method();
}
}
```
2.3 局部内部类（明白）

• 局部内部类定义位置
  

* 局部内部类是在方法中定义的类

• 局部内部类方式方式
  

* 局部内部类，外界是无法直接使用，须要在方法内部创建对象并使用
* 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

• 示例代码
  

```java
class Outer {
private int num = 10;
public void method() {
int num2 = 20;
class Inner {
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
```
2.4 匿名内部类（应用）

• 匿名内部类的前提
  

* 存在一个类大概接口，这里的类可以是具体类也可以是抽象类

• 匿名内部类的格式
  

* 格式：new 类名 ( ) {  重写方法 }    new  接口名 ( ) { 重写方法 }
* 举例：
```java
new Inter(){
@Override
public void method(){}
}
```

• 匿名内部类的本质
  

* 本质：是一个继承了该类大概实现了该接口的子类匿名对象

• 匿名内部类的细节
  

* 匿名内部类可以通过多态的情势接受
```java
Inter i = new Inter(){
@Override
public void method(){
}
}
```

• 匿名内部类直接调用方法
  

```java
interface Inter{
void method();
}
class Test{
public static void main(String[] args){
new Inter(){
@Override
public void method(){
System.out.println("我是匿名内部类");
}
}.method();   // 直接调用方法
}
}
```
2.4 匿名内部类在开发中的使用（应用）

• 匿名内部类在开发中的使用
  

* 当发现某个方法须要，接口或抽象类的子类对象，我们就可以通报一个匿名内部类过去，来简化传统的代码

• 示例代码：
  

```java
interface Jumpping {
void jump();
}
class Cat implements Jumpping {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
class Dog implements Jumpping {
@Override
public void jump() {
System.out.println("狗可以跳高了");
}
}
class JumppingOperator {
public void method(Jumpping j) { //new Cat();   new Dog();
j.jump();
}
}
class JumppingDemo {
public static void main(String[] args) {
//需求：创建接口操作类的对象，调用method方法
JumppingOperator jo = new JumppingOperator();
Jumpping j = new Cat();
jo.method(j);
Jumpping j2 = new Dog();
jo.method(j2);
System.out.println("--------");
// 匿名内部类的简化
jo.method(new Jumpping() {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
});
// 匿名内部类的简化
jo.method(new Jumpping() {
@Override
public void jump() {
System.out.println("狗可以跳高了");
}
});
}
}
```
3. 常用API

3.1 Math（应用）

• 1、Math类概述
  

* Math 包含执行基本数字运算的方法

• 2、Math中方法的调用方式
  

* Math类中无构造方法，但内部的方法都是静态的，则可以通过   类名.进行调用

• 3、Math类的常用方法
  

| 方法名    方法名                               | 阐明                                           |
| ---------------------------------------------- | ---------------------------------------------- |
| public static int   abs(int a)                 | 返回参数的绝对值                               |
| public static double ceil(double a)            | 返回大于或等于参数的最小double值，等于一个整数 |
| public static double floor(double a)           | 返回小于或等于参数的最大double值，等于一个整数 |
| public   static int round(float a)             | 按照四舍五入返回最接近参数的int                |
| public static int   max(int a,int b)           | 返回两个int值中的较大值                        |
| public   static int min(int a,int b)           | 返回两个int值中的较小值                        |
| public   static double pow (double a,double b) | 返回a的b次幂的值                               |
| public   static double random()                | 返回值为double的正值，[0.0,1.0)                |
3.2 System（应用）

• System类的常用方法
  

| 方法名                                   | 阐明                                             |
| ---------------------------------------- | ------------------------------------------------ |
| public   static void exit(int status)    | 停止当前运行的   Java   假造机，非零表示异常停止 |
| public   static long currentTimeMillis() | 返回当前时间(以毫秒为单位)                       |

• 示例代码
  

* 需求：在控制台输出1-10000，盘算这段代码执行了多少毫秒
```java
public class SystemDemo {
public static void main(String[] args) {
// 获取开始的时间节点
long start = System.currentTimeMillis();
for (int i = 1; i  Generate -> 选择toString

• toString方法的作用：
  

* 以良好的格式，更方便的展示对象中的属性值

• 示例代码：
  

```java
class Student extends Object {
private String name;
private int age;
public Student() {
}
public Student(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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("林青霞");
s.setAge(30);
System.out.println(s);
System.out.println(s.toString());
}
}
```

• 运行效果：
  

```java
Student{name='林青霞', age=30}
Student{name='林青霞', age=30}
```
3.4 Object类的equals方法（应用）

• equals方法的作用
  

* 用于对象之间的比较，返回true和false的效果
* 举例：s1.equals(s2);    s1和s2是两个对象

• 重写equals方法的场景
  

* 不希望比较对象的地址值，想要结合对象属性进行比较的时间。

• 重写equals方法的方式
  

* 1. alt + insert  选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
* 2. 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，背面的同上。

• 示例代码：
  

```java
class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
@Override
public boolean equals(Object o) {
//this -- s1
//o -- s2
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o; //student -- s2
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
}
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
Student s2 = new Student();
s2.setName("林青霞");
s2.setAge(30);
//需求：比较两个对象的内容是否相同
System.out.println(s1.equals(s2));
}
}
```
3.5 冒泡排序原理（明白）

• 冒泡排序概述
  

* 一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在背面，依次对全部的数据进行操作，直至全部数据按要求完成排序

• 如果有n个数据进行排序，总共须要比较n-1次
  
• 每一次比较完毕，下一次的比较就会少一个数据参与
  

3.6 冒泡排序代码实现（明白）

• 代码实现
  

1. /*
3.     冒泡排序：
5.         一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
7.         依次对所有的数据进行操作，直至所有数据按要求完成排序
9.  */
11. public class ArrayDemo {
13.     public static void main(String[] args) {
15.         //定义一个数组
17.         int[] arr = {24, 69, 80, 57, 13};
19.         System.out.println("排序前：" + arrayToString(arr));
21.   
23.         // 这里减1，是控制每轮比较的次数
25.         for (int x = 0; x < arr.length - 1; x++) {
27.             // -1是为了避免索引越界，-x是为了调高比较效率
29.             for (int i = 0; i < arr.length - 1 - x; i++) {
31.                 if (arr[i] > arr[i + 1]) {
33.                     int temp = arr[i];
35.                     arr[i] = arr[i + 1];
37.                     arr[i + 1] = temp;
39.                 }
41.             }
43.         }
45.         System.out.println("排序后：" + arrayToString(arr));
47.   
49.     }
51.   
53.     //把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]
55.     public static String arrayToString(int[] arr) {
57.         StringBuilder sb = new StringBuilder();
59.         sb.append("[");
61.         for (int i = 0; i < arr.length; i++) {
63.             if (i == arr.length - 1) {
65.                 sb.append(arr[i]);
67.             } else {
69.                 sb.append(arr[i]).append(", ");
71.             }
73.         }
75.         sb.append("]");
77.         String s = sb.toString();
79.         return s;
81.     }
83. }

复制代码

3.7 Arrays（应用）

• Arrays的常用方法
  

| 方法名                                 | 阐明                               |
| -------------------------------------- | ---------------------------------- |
| public static String toString(int[] a) | 返回指定命组的内容的字符串表示情势 |
| public static void sort(int[] a)       | 按照数字次序排列指定的数组         |

• 工具类设计头脑
  

1、构造方法用 private 修饰
2、成员用 public static 修饰
day04-常用API&异常

1.包装类

1.1基本范例包装类（记忆）

• 基本范例包装类的作用
  

​ 将基本数据范例封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
​ 常用的操作之一：用于基本数据范例与字符串之间的转换

• 基本范例对应的包装类
  

| 基本数据范例 | 包装类    |
| ------------ | --------- |
| byte         | Byte      |
| short        | Short     |
| int          | Integer   |
| long         | Long      |
| float        | Float     |
| double       | Double    |
| char         | Character |
| boolean      | Boolean   |
1.2Integer类（应用）

• Integer类概述
  

​ 包装一个对象中的原始范例 int 的值

• Integer类构造方法
  

| 方法名                                  | 阐明                                     |
| --------------------------------------- | ---------------------------------------- |
| public Integer(int   value)             | 根据 int 值创建 Integer 对象(过期)       |
| public Integer(String s)                | 根据 String 值创建 Integer 对象(过期)    |
| public static Integer valueOf(int i)    | 返回表示指定的 int 值的 Integer   实例   |
| public static Integer valueOf(String s) | 返回一个保存指定值的 Integer 对象 String |

• 示例代码
  

```java
public class IntegerDemo {
public static void main(String[] args) {
//public Integer(int value)：根据 int 值创建 Integer 对象(过期)
Integer i1 = new Integer(100);
System.out.println(i1);
//public Integer(String s)：根据 String 值创建 Integer 对象(过期)
Integer i2 = new Integer("100");
//        Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("--------");
//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 String
Integer i4 = Integer.valueOf("100");
System.out.println(i4);
}
}
```
1.3int和String范例的相互转换（记忆）

• int转换为String
  

- 转换方式
- 方式一：直接在数字后加一个空字符串
- 方式二：通过String类静态方法valueOf()
- 示例代码
```java
public class IntegerDemo {
public static void main(String[] args) {
//int --- String
int number = 100;
//方式1
String s1 = number + "";
System.out.println(s1);
//方式2
//public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("--------");
}
}
```

• String转换为int
  

- 转换方式
- 方式一：先将字符串数字转成Integer，再调用valueOf()方法
- 方式二：通过Integer静态方法parseInt()进行转换
- 示例代码
```java
public class IntegerDemo {
public static void main(String[] args) {
//String --- int
String s = "100";
//方式1：String --- Integer --- int
Integer i = Integer.valueOf(s);
//public int intValue()
int x = i.intValue();
System.out.println(x);
//方式2
//public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
```
1.4字符串数据排序案例（应用）

• 案例需求
  

​ 有一个字符串：“91 27 46 38 50”，请写程序实现最终输出效果是：“27 38 46 50 91”

• 代码实现
  

```java
public class IntegerTest {
public static void main(String[] args) {
//定义一个字符串
String s = "91 27 46 38 50";
//把字符串中的数字数据存储到一个int范例的数组中
String[] strArray = s.split(" ");

//        for(int i=0; i：表示元素范例未知的List，它的元素可以匹配任何的范例 list1 = new ArrayList list2 = new ArrayList list3 = new ArrayList