Java面向对象与常用类

1. 面向对象思想

1.1 面向对象思想概述

这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。

面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

1.2 类和对象

什么是类

• 类 ：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：（eg.学生）

• 属性 ：就是该事物的状态信息。（eg.姓名、年龄）
• 行为 ：就是该事物能够做什么。（eg.吃饭、睡觉、学习）

什么是对象

• 对象 ：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

类与对象的关系

• 类是对一类事物的描述，是 抽象的 。
• 对象是一类事物的实例，是 具体的 。
• 类是对象的模板，对象是类的实体 。

1.3 类的定义

事物与类的对比
      现实世界的一类事物：
      属性：事物的状态信息。 行为：事物能够做什么。
      Java中用class描述事物也是如此：
      成员变量：对应事物的属性。 成员方法：对应事物的行为

类的定义格式

public class ClassName {
  //成员变量
  //成员方法
}

• 定义类 ：就是定义类的成员，包括成员变量和成员方法。
• 成员变量 ：直接定义在类中的方法外面。
• 成员方法 ：和以前定义方法几乎是一样的，但要把static去掉。

类的定义格式举例：

//Student类定义在包中的一个单独的class中，在使用相应对象时导包即可
public class Student {
   //成员变量  
   String name；//姓名  
    int age；//年龄
   //成员方法
   //学习的方法
   public void study() {
    System.out.println("好好学习，天天向上");
  }
   //吃饭的方法
   public void eat() {
    System.out.println("学习饿了要吃饭");
  }
}

1.4 对象的使用

对象的使用格式
  通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用。
  ①导包：也就是指出需要使用的类在什么位置
      格式：import 包名称.类名称；
      举例：import cn.itcast.day03.demo01.Student;
      注：对于和当前属于同一个包的情况，可以省略导包语句
  ②创建：
      格式：类名称 对象名 = new 类名称();
      举例：Student stu = new Student();
  ③使用：
      使用成员变量：对象名.成员变量名;
      使用成员方法：对象名.成员方法名(参数);

对象的使用格式举例:

//注：Student类已经在同一个包中定义好
//这里只显示Student类的对象的使用
public class Test01_Student {
  public static void main(String[] args) {
    //创建对象格式：类名 对象名 = new 类名();
    Student s = new Student();
    System.out.println("s:"+s); //cn.itcast.Student@100363
    //直接输出成员变量值
    System.out.println("姓名："+s.name); //null
    System.out.println("年龄："+s.age); //0
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    //给成员变量赋值
    s.name = "张学霸";
    s.age = 18;
    //再次输出成员变量的值
    System.out.println("姓名："+s.name); //张学霸
    System.out.println("年龄："+s.age); //18
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    //调用成员方法
    s.study(); // "好好学习，天天向上"
    s.eat(); // "学习饿了要吃饭"
   }
  }

成员变量的默认值

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	‘\u0000’
	布尔（boolean）	false
引用类型	数组，类，接口	null

1.5 类与对象的练习

第一步：定义手机类：

public class Phone {
  // 成员变量
  String brand; //品牌
  int price; //价格
  String color; //颜色
  // 成员方法
  //打电话
  public void call(String name) {
    System.out.println("给"+name+"打电话");
  }
  //发短信
  public void sendMessage() {
    System.out.println("群发短信");
  }
}

第二步：定义测试类：

public class Test02Phone {
  public static void main(String[] args) {
    //创建对象
    //根据Phone类，创建一个名为p的对象
    Phone p = new Phone();
    //输出默认的成员变量值
    System.out.println("品牌："+p.brand);//null
    System.out.println("价格："+p.price);//0
    System.out.println("颜色："+p.color);//null
    System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
    //给成员变量赋值，这样对象p就有了自己独有的信息
    p.brand = "锤子";
    p.price = 2999;
    p.color = "棕色";
    //再次输出成员变量值
    System.out.println("品牌："+p.brand);//锤子
    System.out.println("价格："+p.price);//2999
    System.out.println("颜色："+p.color);//棕色
    System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
    //调用成员方法
    p.call("紫霞");
    p.sendMessage();
  }
}

1.6 对象内存图

• ①只有一个对象的内存图
  

如上图，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中的空间，寻找方法信息，去执行该方法。

但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存了，因为所有对象的方法信息都是一样的。那么如何解决这个问题呢？请看如下图解。

• ②两个对象使用同一个方法的内存图
  

对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。

• ③两个引用指向同一个对象的内存图
  
• ④使用对象类型作为方法的参数
  

引用类型作为参数，传递的是地址值。

• ⑤使用对象类型作为方法的返回值
  

1.7 成员变量和局部变量区别

在类中的位置不同 【重点】

• 成员变量：类中，方法外
• 局部变量：方法中或者方法声明上 (形式参数)

作用范围不一样 【重点】

• 成员变量：类中
• 局部变量：方法中

初始化值的不同 【重点】

• 成员变量：有默认值
• 局部变量：没有默认值。必须先定义，赋值，最后使用

在内存中的位置不同

• 成员变量：堆内存
• 局部变量：栈内存

生命周期不同

• 成员变量：随着对象的创建而存在，随着对象的消失而消失
• 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

2. 封装

面向对象三大特征：封装性、继承性、多态性

2.1 封装概述

概述
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
原则
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

2.2 封装的步骤

1.使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

2.3 封装的操作——private关键字

private的含义

• 1.private是一个权限修饰符，代表最小权限。
• 2.可以修饰成员变量和成员方法。
• 3.被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

private 数据类型 变量名 ；

1.使用 private 修饰成员变量，代码如下：

public class Student {
  private String name;//姓名
  private int age;//年龄
  private boolean male;//是否为男性
}

2.提供 getXxx 方法 / setXxx 方法，代码如下：

public class Student {
  private String name; //姓名
  private int age; //年龄
  private boolean male; //是否为男性
  public void setName(String n) {
    name = n;
  }
  public String getName() {
    return name;
  }
  public void setAge(int a) {
    age = a;
  }
  public int getAge() {
    return age;
  }
  public void setMale(boolean b){
    male = b;
  }
  public boolean isMale(){   //注意boolean值对应Getter的写法
    return male;
  }
}

对于Setter来说，不能有返回值，参数类型和成员变量对应
对于Getter来说，不能有参数，返回值类型和成员变量对应

    注：对于基本类型中的boolean值，Getter方法一定要学成isXxx的形式，而setXxx不变

生成getXxx 方法 / setXxx 方法快捷键：Alt+Insert

3.在main方法中以间接访问的方式给成员变量赋值或者获取数据，代码如下：

public class Demo01Student {
    public static void main(String[] args) {
        Student stu = new Student();  //创建对象
        //用间接访问的方式给对象stu的成员变量赋值
        stu.setName("张学霸"); 
        stu.setAge(20); 
        stu.setMale(true);
        
        //用间接访问的方式获取对象stu的成员变量数据
        System.out.println("姓名"+stu.getName()); 
        System.out.println("年龄"+stu.getAge());
        System.out.println("是否为男性"+stu.isMale());
    }
}

2.4 封装优化1——this关键字

我们发现 setXxx 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？代码如下：

public class Student {
  private String name;
  private int age;
  public void setName(String name) {
    name = name;
  }
  public void setAge(int age) {
    age = age;
  }
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了setXxx() 的形参变量名后，方法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，根据“就近原则”优先使用了局部变量，即导致成员变量名被隐藏，方法中的变量名无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。

this的含义
    this代表所在类的当前对象的引用（地址值），即对象自己的引用。

注：方法被哪个对象调用，方法中的this就代表那个对象。即 “谁在调用，this就代表谁” 。

this使用格式

this.成员变量名；

使用 this 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student {
  private String name;
  private int age;
  public void setName(String name) {
    //name = name;
    this.name = name;
  }
  public String getName() {
    return name;
  }
  public void setAge(int age) {
    //age = age;
    this.age = age;
  }
  public int getAge() {
    return age;
  }
}

注：方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

2.5 封装优化2——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。当我们通过关键字new来创建对象时，其实就是在调用构造方法。

注：无论你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式

修饰符 构造方法名(参数列表){
// 方法体    
}

注意：
    1.构造方法的名称必须和所在类名称完全一样，就连大小写也要一样
    2.构造方法不要写返回值类型，就连void都不写，当然也不能return一个具体的返回值
    3.访问权限可以为任意，但是一般情况下使用public方法权限，即修饰符一般为public

使用构造方法后，代码如下：

public class Student {
    // 成员变量
    private String name;
    private int age;
    // 无参数的构造方法
    public Student() {
        System.out.println("无参构造方法执行啦！");
    }
    // 全参数的构造方法
    public Student(String name, int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name;
        this.age = age;
    }
    // Getter/Setter
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

public class Demo02Student {
    public static void main(String[] args) {
        Student stu1 = new Student(); // 无参构造
        Student stu2 = new Student("张学霸", 20); // 全参构造，无需使用setXxx方法
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
        stu2.setAge(21); // 改变年龄
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}

注意事项

1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。重载即方法名称相同，参数列表不同。

构造方法的使用
java中构造方法的使用有两个地方，一个是跟在关键字new后面，类名加上一个小括号()，小括号内根据实际加上实参，另外一个是跟在关键字super或this后加上一个小括号()，小括号内根据实际添加实参。

生成构造方法快捷键：Alt+Insert

2.6 标准代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

构成

public class ClassName{
  //成员变量，所有的成员变量都要使用private关键字修饰
  
  //构造方法
  //无参构造方法【必须】
  //有参构造方法【建议】
  
  //成员方法，为每一个成员变量编写一对儿Getter/Setter方法   
  //getXxx()
  //setXxx()
}

编写符合 JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
  //成员变量
  private String name;
  private int age;
  //构造方法
  public Student() {}
  public Student(String name,int age) {
    this.name = name;
    this.age = age;
  }
  //成员方法
  publicvoid setName(String name) {
    this.name = name;
  }
  public String getName() {
    return name;
  }
  publicvoid setAge(int age) {
    this.age = age;
  }
  publicint getAge() {
    return age;
  }
}

public class TestStudent {
  public static void main(String[] args) {
    //无参构造使用
    Student s= new Student();
    s.setName("扛把子");
    s.setAge(18);
    System.out.println(s.getName()+"‐‐‐"+s.getAge());
    //带参构造使用
    Student s2= new Student("张学霸",18);
    System.out.println(s2.getName()+"‐‐‐"+s2.getAge());
  }
}

3. Scanner类

3.1 什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。 例如，以下代码使用户能够从System.in 中读取一个数：

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

注：System.in 系统输入指的是通过键盘录入数据。

3.2 引用类型使用步骤

①导包
使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。
格式：

import 包路径.类名称;

举例：

import  java.util.Scanner;

• 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
• 只有java.lang包下的内容不需要导包，其他的包都需要import语句。

②创建对象
使用该类的构造方法，创建一个该类的对象。
格式：

类名称 对象名 = new 类名称(参数列表);

举例：

Scanner sc = new Scanner(System.in); //System.in代表从键盘进行输入

③调用方法
调用该类的成员方法，完成指定功能。
格式：

对象名.成员方法名();

举例：

int num = sc.nextInt();  //获取键盘输入的一个int数字：
String str = sc.next();  //获取键盘输入的一个字符串：

注：使用IDEA开发中可以跳过导包直接创建，导包语句会自动生成，如果没有生成则可以将鼠标放在红色的类名处使用快捷键Alt+Enter即可生成。

2.3 Scanner 使用步骤

使用Scanner类，完成接收键盘录入数据的操作，代码如下：

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
   public static void main(String[] args) {  
     //2. 创建键盘录入数据的对象    
     Scanner sc = new Scanner(System.in);    
     //3. 接收数据    
     System.out.println("请录入一个整数：");    
     int i = sc.nextInt();    
     //4. 输出数据    
     System.out.println("i:"+i);    
   }  
}

3.4 练习

求和
键盘录入两个数据并求和，代码如下：

import java.util.Scanner;
public class Test01Scanner {
  public static void main(String[] args) {
    // 创建对象
    Scanner sc = new Scanner(System.in);
    // 接收数据
    System.out.println("请输入第一个数据：");
    int a = sc.nextInt();
    System.out.println("请输入第二个数据：");
    int b = sc.nextInt();
    // 对数据进行求和
    int sum = a + b;
        System.out.println("sum:" + sum);
  }
}

取最值
键盘录入三个数据并获取最大值，代码如下：

import java.util.Scanner;
public class Test02Scanner {
  public static void main(String[] args) {
    // 创建对象
    Scanner sc = new Scanner(System.in);
    // 接收数据
    System.out.println("请输入第一个数据：");
    int a = sc.nextInt();
    System.out.println("请输入第二个数据：");
    int b = sc.nextInt();
    System.out.println("请输入第三个数据：");
    int c = sc.nextInt();
    // 如何获取三个数据的最大值
    int temp = (a > b ? a : b);
    int max = (temp > c ? temp : c);
    System.out.println("max:" + max);
  }
}

3.5 匿名对象

概念
创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。

创建对象的标准格式：

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

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符：

new 类名称();

注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

匿名对象可以作为方法的参数和返回值

• 作为参数：

class Test {
    public static void main(String[] args) {
      // 普通方式   
        Scanner sc = new Scanner(System.in); 
        input(sc);
     
        //匿名对象作为方法接收的参数
        input(new Scanner(System.in));
    }
 
  public static void input(Scanner sc){   
     System.out.println(sc);    
   }  
}

• 作为返回值：

class Test2 {
    public static void main(String[] args) {  
      // 普通方式   
        Scanner sc = getScanner();
    }
   
   public static Scanner getScanner(){  
        //普通方式
        //Scanner sc = new Scanner(System.in); 
        //return sc;
     
        //匿名对象作为方法返回值
        return new Scanner(System.in);
   }    
}

4. Random类

4.1 什么是Random类

Random类用来生成伪随机数。

例如，以下代码使用户能够得到一个随机数：

Random r = new Random();
int i = r.nextInt();

4.2 Random 使用步骤

①导包

import java.util.Random;

②创建

Random r = new Random(); // 小括号当中留空即可

③使用

• 获取一个随机的int数字（范围是int所有范围，有正负两种）：

int num = r.nextInt()；

• 获取一个随机的int数字（参数代表了范围，左闭右开区间）：

int num = r.nextInt(3)；//实际上代表的含义是：[0,3)，也就是0~2

注：创建一个 Random 对象，每次调用 nextInt() 方法，都会生成一个随机数。

4.3 练习

获取随机数
获取1-n之间的随机数，包含n，代码如下：

// 导包
import java.util.Random;
public class Test01Random {
  public static void main(String[] args) {
    int n = 50;
    // 创建对象
    Random r = new Random();
    // 获取随机数
    // 本来范围是[0,n)，整体+1之后变成了[1,n+1)，也就是[1,n]
    int number = r.nextInt(n) + 1;
    // 输出随机数
    System.out.println("number:" + number);
  }
}

猜数字小游戏
游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与 number 作比较，系统提示大了或者小了，直到玩家猜中，游戏结束。

// 导包
import java.util.Random;
public class Test02Random {
  public static void main(String[] args) {
    // 系统产生一个随机数1‐100之间的。
    Random r = new Random();
    int number = r.nextInt(100) + 1;
    //循环次数不确定所以使用while循环
    while(true){
      // 键盘录入我们要猜的数据
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入你要猜的数字(1‐100)：");
      int guessNumber = sc.nextInt();
      // 比较这两个数据(用if语句)
      if (guessNumber > number) {
        System.out.println("你猜的数据" + guessNumber + "大了");
      } else if (guessNumber < number) {
        System.out.println("你猜的数据" + guessNumber + "小了");
      } else {
        System.out.println("恭喜你,猜中了");
        break;// 如果猜中，不再重试
      }
    }
  }
}

5. ArrayList类

5.1 引入——对象数组

使用学生数组，存储三个学生对象，代码如下：

public 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;
  }
  publicvoid setName(String name) {
    this.name = name;
  }
  publicint getAge() {
    return age;
  }
  publicvoid setAge(int age) {
    this.age = age;
  }
}

public class Test01StudentArray {
  public static void main(String[] args) {
    //创建学生数组
    Student[] students = new Student[3];
    //创建学生对象
    Student s1 = new Student("曹操",40);
    Student s2 = new Student("刘备",35);
    Student s3 = new Student("孙权",30);
    //把学生对象作为元素赋值给学生数组
    students[0] = s1;
    students[1] = s2;
    students[2] = s3;
    //遍历学生数组
    for(int x=0; x<students.length; x++) {
      Student s = students[x];
      System.out.println(s.getName()+"‐‐‐"+s.getAge());
    }
  }
}

在之前想存储对象数据，可选择的容器只有对象数组。而数组的长度是固定的，无法适应数据变化的需求。

5.2什么是ArrayList类

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长。

5.3ArrayList 使用步骤

①导包

import java.util.ArrayList;

②创建

ArrayList<E> list = new ArrayList<>();E

对于ArrayList来说，有一个尖括号< E >代表泛型。
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。

③使用举例

public boolean add(E e) ： 将指定的元素添加到此集合的尾部。

注：参数 E e ，在构造ArrayList对象时， < E > 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据类型的对象。

使用ArrayList类，存储三个字符串元素，代码如下：

public class Test02StudentArrayList {
  public static void main(String[] args) {
    //创建学生数组
    ArrayList<String> list = new ArrayList<>();
    //创建学生对象
    String s1 = "曹操";
    String s2 = "刘备";
    String s3 = "孙权";
    //打印学生ArrayList集合
    System.out.println(list);
    //把学生对象作为元素添加到集合
    list.add(s1);
    list.add(s2);
    list.add(s3);
        //打印学生ArrayList集合
    System.out.println(list);
  }
}

5.4常用方法和遍历

对于元素的操作,基本体现在——增、删、查。常用的方法有：

• public boolean add(E e) ：将指定的元素添加到此集合的尾部。
• public E remove(int index)：移除此集合中指定位置上的元素。返回被删除的元素。
• public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
• public int size()：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

这些都是最基本的方法，操作非常简单，代码如下:

public class Demo01ArrayListMethod {
  public static void main(String[] args) {
    //创建集合对象
    ArrayList<String> list = new ArrayList<String>();
    //添加元素
    list.add("hello");
    list.add("world");
    list.add("java");
    //public E get(int index):返回指定索引处的元素
    System.out.println("get:"+list.get(0));
    System.out.println("get:"+list.get(1));
    System.out.println("get:"+list.get(2));
    //public int size():返回集合中的元素的个数
    System.out.println("size:"+list.size());
    //public E remove(int index):删除指定索引处的元素，返回被删除的元素
    System.out.println("remove:"+list.remove(0));
    //遍历输出
    for(int i = 0; i < list.size(); i++){
      System.out.println(list.get(i));
    }
  }
}

5.5 如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 < int > 不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer 【特殊】
long	Long
float	Float
double	Double
char	Character 【特殊】
boolean	Boolean

例如向集合中存入int类型数据，代码如下：

public class Demo02ArrayListMethod {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    System.out.println(list);    
  }
}

5.6 ArrayList 练习

题目一：数值添加到集合

生成6个1~33之间的随机整数，添加到集合，并遍历集合。

  思路：
  1.需要存储6个数字，创建一个集合，
  2.产生随机数，需要用到Random
  3.用循环6次，来产生6个随机数字：for循环
  4.循环内调用r.nextInt(int n)，参数是33，0_{32，整体+1才是1}33
  5.把数字添加到集合中：add
  6.遍历集合：for、size、get

public class Test01ArrayList {
  public static void main(String[] args) {
    // 创建Random 对象
    Random random = new Random();
    // 创建ArrayList 对象
    ArrayList<Integer> list = new ArrayList<>();
    // 添加随机数到集合
    for (int i = 0; i < 6; i++) {
      int r = random.nextInt(33) + 1;
            list.add(r);
    }
    // 遍历集合输出
    for (int i = 0; i < list.size(); i++) {
      System.out.println(list.get(i));
    }
  }
}

对象添加到集合

自定义4个学生对象，添加到集合，并遍历。

  思路：
  1.自定义Student学生类，四个部分。
  2.创建一个集合，用来存储学生对象。泛型：
  3.根据类，创建4个学生对象。
  4.将4个学生对象添加到集合中：add
  5.遍历集合：for、size、get

public class Test02ArrayList {
  public static void main(String[] args) {
    //创建集合对象
    ArrayList<Student> list = new ArrayList<Student>();
    //创建学生对象
    Student s1 = new Student("赵丽颖",18);
    Student s2 = new Student("唐嫣",20);
    Student s3 = new Student("景甜",25);
    Student s4 = new Student("柳岩",19);
    //把学生对象作为元素添加到集合中
    list.add(s1);
    list.add(s2);
    list.add(s3);
    list.add(s4);
    //遍历集合
    for(int x = 0; x < list.size(); x++) {
      Student s = list.get(x);
      System.out.println(s.getName()+"‐‐‐"+s.getAge());
    }
  }
}

打印集合方法

定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}扩起集合，使用@分隔每个元素。
格式参照 {元素@元素@元素}。

public class Test03ArrayList {
  public static void main(String[] args) {
    // 创建集合对象
    ArrayList<String> list = new ArrayList<String>();
    // 添加字符串到集合中
    list.add("张三丰");
    list.add("宋远桥");
        list.add("张无忌");
    list.add("殷梨亭");
    // 调用方法
    printArrayList(list);
  }
  /*
    定义方法的三要素
    返回值类型：只是进行打印而已，没有运算，没有结果；所以用void
    方法名称：printArrayList
    参数列表：ArrayList
     */
  public static void printArrayList(ArrayList<String> list) {
    // 拼接左括号
    System.out.print("{");
    // 遍历集合
    for (int i = 0; i < list.size(); i++) {
      // 获取元素
      String s = list.get(i);
      // 拼接@符号
      if (i != list.size() ‐ 1) {
        System.out.print(s + "@");
      } else {
        // 拼接右括号
        System.out.print(s + "}");
      }
    }
  }
}

获取集合方法

用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。 要求使用自定义的方法来实现筛选。

  分析：
  1.需要创建一个大集合，用来存储int数字：
  2.随机数字就用Random nextInt
  3.循环20次，把随机数字放入大集合：for循环、add方法
  4.定义一个方法，用来进行筛选。
     筛选：根据大集合，筛选符合要求的元素，得到小集合。
     三要素
     返回值类型：ArrayList小集合（里面元素个数不确定）
     方法名称：getSmallList
     参数列表：ArrayList大集合（装着20个随机数字）
  5.判断（if）是偶数：num % 2 == 0
  6.如果是偶数，就放到小集合当中，否则不放。

public class Test04ArrayList {
  public static void main(String[] args) {
    // 创建Random 对象
    Random random = new Random();
    // 创建ArrayList 对象
    ArrayList<Integer> list = new ArrayList<>();
    // 添加随机数到集合
    for (int i = 0; i < 20; i++) {
      int r = random.nextInt(1000) + 1;
      list.add(r);
    }
    // 调用偶数集合的方法
    ArrayList<Integer> arrayList = getArrayList(list);
    System.out.println("偶数总共有多少个：" + arrayList.size());
    System.out.println(arrayList);
  }
  // 这个方法，接收大集合参数，返回小集合结果
  public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) {
    // 创建小集合,来保存偶数
    ArrayList<Integer> smallList = new ArrayList<>();
    // 遍历list
    for (int i = 0; i < list.size(); i++) {
      // 获取元素
            Integer num = list.get(i);
      // 判断为偶数,添加到小集合中
      if (num % 2 == 0){
        smallList.add(num);
      }
    }
    // 返回小集合
    return smallList;
  }
}

6. String类

6.1 String 类概述

概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc”）都可以被看作是实现此类的实例。即，程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

字符串特点

• 1.字符串的内容永不可变。【重点】

// 下面这种写法，字符串的内容仍然是没有改变的
// 下面有两个字符串："abc"，"abcd"
// s1当中保存的是地址值。
// 本来地址值是abc的0x666，
// 后来地址值变成了abcd的0x999
String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"

• 2.正是因为字符串不可改变，所以字符串是可以共享使用的。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

• 3.字符串效果上相当于是char[]字符数组 即，“abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。但是注意其底层原理是byte[]字节数组。

 例如：
String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};    
String str = new String(data);
// String底层是靠字符数组实现的。

6.2创建字符串的常见3+1种方式

• 三种构造方法：

public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。

// 使用空参构造
String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。

// 根据字符数组创建字符串
char[] charArray = { 'A', 'B', 'C' };
String str2 = new String(charArray);

// 根据字节数组创建字符串
byte[] byteArray = { 97, 98, 99 };
String str3 = new String(byteArray);

• 一种直接创建：

String str = “Hello”; // 右边直接用双引号

// 直接创建
String str4 = "Hello";

注意：直接写上双引号，就是字符串对象。

• 字符串常量池

程序当中直接写上的双引号字符串，就在字符串常量池中

    举例：

public class Demo02StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] charArray = {'a', 'b', 'c'};
        String str3 = new String(charArray);

        //对于基本类型来说，==是进行数值的比较。
		//对于引用类型来说，==是进行【地址值】的比较。
        System.out.println(str1 == str2); // true
        System.out.println(str1 == str3); // false
        System.out.println(str2 == str3); // false
    }
}

6.3 常用方法

6.3.1 判断功能的方法

   ==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

方法一：
public boolean equals(Objectobj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。

     注意事项：
        1. 任何对象都能用Object进行接收。
        2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
        3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。 推荐：“abc”.equals(str) 不推荐：str.equals(“abc”)

方法二：
public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

方法演示，代码如下：

public class String_Demo01 {
  public static void main(String[] args) {
    // 创建字符串对象
    String s1 = "hello";
    String s2 = "hello";
    String s3 = "HELLO";
    
    // boolean equals(Object obj):比较字符串的内容是否相同
    System.out.println(s1.equals(s2)); // true
    System.out.println(s1.equals(s3)); // false
    System.out.println(str1.equals("hello")); // true
    System.out.println("hello".equals(str1)); // true, a.equals(b)和b.equals(a)效果一样
    System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    //如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
    String str5 = null;
    System.out.println("abc".equals(str5)); // 推荐：false
	//System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException
    
    //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    System.out.println(s1.equalsIgnoreCase(s2)); // true
    System.out.println(s1.equalsIgnoreCase(s3)); // true
    System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
  }
}

注：Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

6.3.2 获取功能的方法

• public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
• public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。注：也可直接使用+=实现字符串拼接
• public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
• public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。
• public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
• public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。 注：[begin,end)，包含左边，不包含右边。

方法演示，代码如下：

public class Demo02StringGet {
    public static void main(String[] args) {
        // 获取字符串的长度，其实也就是字符个数
        String s = "helloworld";
        System.out.println(s.length());
        int length = "asdasfeutrvauevbueyvb".length();
        System.out.println("字符串的长度是：" + length);

        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // Hello，原封不动
        System.out.println(str2); // World，原封不动
        System.out.println(str3); // HelloWorld，新的字符串

        // 获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);

        // 查找参数字符串在本来字符串当中出现的第一次索引位置
        // 如果根本没有，返回-1值
        String original = "HelloWorldHelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是：" + index); // 2
        System.out.println("HelloWorld".indexOf("abc")); // -1

    	//截取从参数位置一直到字符串末尾，返回新字符串。
        String str01 = "HelloWorld";
        String str02 = str01.substring(5);
        System.out.println(str01); // HelloWorld，原封不动
        System.out.println(str02); // World，新字符串

		//截取从begin开始，一直到end结束，中间的字符串。
        String str03 = str01.substring(4, 7);
        System.out.println(str03); // oWo
    }
}

6.3.3 转换功能的方法

• public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
• public byte[] getBytes()：获得当前字符串底层的字节数组。
• public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

     注：CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

方法演示，代码如下：

public class Demo04StringConvert {
    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?

        String lang1 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！";
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang2); // 会不会玩儿呀！****！****！****！！！
    }
}

6.3.4 分割功能的方法

public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分，返回字符串数组。
注意事项：split方法的参数其实是一个“正则表达式”，如果按照英文句点“.”进行切分，必须写"\."（两个反斜杠）

public class Demo05StringSplit {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(","); //["aaa","bbb","ccc"]
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]); //aaa bbb ccc
        }

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" "); //["aaa","bbb","ccc"]
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]); //aaa bbb ccc
        }

        String str3 = "aaa.bbb.ccc";
        String[] array3 = str3.split("\\."); //["aaa","bbb","ccc"]
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]); //aaa bbb ccc
        }
    }
}

6.4 String 类的练习

拼接字符串
定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。

分析：
    1.首先准备一个int[]数组，内容是：1、2、3
    2.定义一个方法，用来将数组变成字符串
        三要素：
            返回值类型：String
            方法名称：fromArrayToString
            参数列表：int[]
    3.格式：[word1#word2#word3]
       用到：for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
    4.调用方法，得到返回值，并打印结果字符串

解法一：用 public String concat(String str) 实现字符串拼接

public class StringTest1 {
  public static void main(String[] args) {
    //定义一个int类型的数组
    int[] arr = {1, 2, 3};
    //调用方法
    String s = arrayToString(arr);
    //输出结果
    System.out.println("s:" + s);
  }
  /*
     * 写方法实现把数组中的元素按照指定的格式拼接成一个字符串
     * 两个明确：
     * 返回值类型：String
     * 参数列表：int[] arr
     */
  public static String arrayToString(int[] arr) {
    // 创建字符串s
        String s = new String("[");
    // 遍历数组，并拼接字符串
    for (int x = 0; x < arr.length; x++) {
      if (x == arr.length ‐ 1) {
        s = s.concat(arr[x] + "]");
      } else {
        s = s.concat(arr[x] + "#");
      }
    }
    return s;
  }
}

解法二：用 += 实现字符串拼接

public class Demo06StringPractise {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};

        String result = fromArrayToString(array);
        System.out.println(result);
    }

    public static String fromArrayToString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                str += "word" + array[i] + "]";
            } else {
                str += "word" + array[i] + "#";
            }
        }
        return str;
    }
}

统计字符个数
键盘录入一个字符，统计字符串中大小写字母及数字字符个数，种类有：大写字母、小写字母、数字、其他

思路：
    1.既然用到键盘输入，肯定是Scanner
    2.键盘输入的是字符串，那么：String str = sc.next();
    3.定义四个变量，分别代表四种字符各自的出现次数。
    4.需要对字符串一个字、一个字检查，String–>char[]，方法就是toCharArray()
    5.遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
    6.打印输出四个变量，分别代表四种字符出现次数。

解法一：用 public char[] toCharArray() 把字符串转换成字符型数组，然后遍历数组获取每一个字符

public class Demo07StringCount {
    public static void main(String[] args) {
   		//键盘录入一个字符串数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next(); // 获取键盘输入的一个字符串
        
		//定义四个统计变量，初始化值都是0
        int countUpper = 0; // 大写字母
        int countLower = 0; // 小写字母
        int countNumber = 0; // 数字
        int countOther = 0; // 其他字符
        
		//遍历字符串，得到每一个字符
		//先把字符串转换成char型数组再遍历数组
        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i]; // 当前单个字符
            if ('A' <= ch && ch <= 'Z') {
                countUpper++;
            } else if ('a' <= ch && ch <= 'z') {
                countLower++;
            } else if ('0' <= ch && ch <= '9') {
                countNumber++;
            } else {
                countOther++;
            }
        }
        
		//输出结果
        System.out.println("大写字母有：" + countUpper);
        System.out.println("小写字母有：" + countLower);
        System.out.println("数字有：" + countNumber);
        System.out.println("其他字符有：" + countOther);
    }
}

解法二：用 public char charAt(int index) 直接遍历字符串，获取每一个字符

public class StringTest2 {
  public static void main(String[] args) {
    //键盘录入一个字符串数据
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串数据：");
    String s = sc.nextLine();
    
    //定义三个统计变量，初始化值都是0
    int bigCount = 0;
    int smallCount = 0;
    int numberCount = 0;
    
    //直接遍历字符串，得到每一个字符
    for(int x=0; x<s.length(); x++) {
      char ch = s.charAt(x);
      //拿字符进行判断
      if(ch>='A'&&ch<='Z') {
        bigCount++;
      }else if(ch>='a'&&ch<='z') {
        smallCount++;
      }else if(ch>='0'&&ch<='9') {
        numberCount++;
      }else {
        System.out.println("该字符"+ch+"非法");
      }
    }
    
    //输出结果
    System.out.println("大写字符："+bigCount+"个");
    System.out.println("小写字符："+smallCount+"个");
    System.out.println("数字字符："+numberCount+"个");
  }
}

7. static关键字

7.1 概述

static 关键字，可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，多个对象共享同一份数据，就可以不靠创建对象来调用了。

7.2 定义和使用格式

7.2.1 类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

定义格式：

static 数据类型 变量名；

举例：

static int numberID；

代码示例：

public class Student {
    
    private String name; // 姓名
    private int age; // 年龄
    // 类变量，所有对象共享
    static String room; // 所在教室
    private int id; // 学号
    // 类变量，记录学生数量，用于分配学号
    private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        this.id = ++idCounter;
    }
	//在全参构造中给出新建对象的学号
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        // 通过 idCounter 给学生分配学号
        this.id = ++idCounter;
    }

    //Getter/Setter
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    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 class Demo01StaticField {

    public static void main(String[] args) {

        Student one = new Student("郭靖", 19);
        //给类变量赋值一次之后创建的所有对象皆可使用
        one.room = "101教室";
        System.out.println("姓名：" + one.getName() + "，年龄：" + one.getAge() + "，教室：" + one.room + "，学号：" + one.getId());
        
        Student two = new Student("黄蓉", 16);
        two.room = "101教室";
        System.out.println("姓名：" + two.getName() + "，年龄：" + two.getAge() + "，教室：" + two.room + "，学号：" + two.getId());
    }
}

7.2.2 静态方法

当 static 修饰成员方法时，该方法称为类方法，习惯称为静态方法 。静态方法在声明中有 static，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

注意事项：
    1.静态不能直接访问非静态。
       原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
    2.静态方法当中不能用this。
       原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

7.2.3调用格式

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

//访问静态变量
类名称.静态变量名；
//访问静态方法
类名称.静态方法名()；

调用演示，代码如下：

public class StuDemo2 {
  public static void main(String[] args) {     
    // 访问类变量
    System.out.println(Student.numberOfStudent);
    // 调用静态方法
    Student.showNum();
  }
}

7.3 静态原理图解

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
• 它优先于对象存在，所以，可以被所有对象共享。
  

7.4 静态代码块

静态代码块 ：定义在成员位置，使用static修饰的代码块{ }。

• 位置：类中方法外。
• 执行：随着类的加载而执行且执行一次，优先于 main方法和构造方法的执行。

格式：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}

作用：

用来一次性地对静态成员变量进行初始化赋值。

示例代码：

public class Game {
  public static int number;
  public static ArrayList<String> list;
  static {
    // 给类变量赋值
    number = 2;
    list = new ArrayList<String>();
    // 添加元素到集合中
    list.add("张三");
    list.add("李四");
  }
}

特点：

• 当第一次用到本类时，静态代码块执行唯一的一次。
• 静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

注：static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。

8. Arrays类

8.1 概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

8.2 操作数组的方法

• public static String toString(int[] a) ：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3…]）

public static void main(String[] args) {
  // 定义int 数组
  int[] arr  =  {2,34,35,4,657,8,69,9};
  // 打印数组,输出地址值
  System.out.println(arr); // [I@2ac1fdc4
  // 数组内容转为字符串
  String s = Arrays.toString(arr);
  // 打印字符串,输出内容
  System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}

• public static void sort(int[] a) ：按照默认升序（从小到大）对数组的元素进行排序。

public static void main(String[] args) {
  // 定义int 数组
  int[] arr  =  {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
  System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6,2]
  // 升序排序
  Arrays.sort(arr);
  System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46,48]
  String[] array2 = {"bbb", "aaa", "ccc"};
  Arrays.sort(array2);
  System.out.println(Arrays.toString(array2)); // 排序后:[aaa, bbb, ccc]

}

8.3 练习

请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public class Demo02ArraysPractise {
    public static void main(String[] args) {
    	// 定义随机的字符串
        String str = "asv76agfqwdfvasdfvjh";

        // 如何进行升序排列：sort
        // 必须是一个数组，才能用Arrays.sort方法
        // String --> 数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars); // 对字符数组进行升序排列

        // 需要倒序遍历
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }
}

9. Math类

9.1 概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

9.2 基本运算的方法

• public static double abs(double a) ：返回 double 值的绝对值。

double d1 = Math.abs(‐5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5

• public static double ceil(double a) ：向上取整，返回大于等于参数的最小的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

• public static double floor(double a) ：向下取整，返回小于等于参数最大的整数。

double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(‐3.3); //d2的值为‐4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

• public static long round(double a) ：四舍五入，返回最接近参数的 long。

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

Math.PI代表近似的圆周率常量（double）。

9.3 练习

计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

  分析：
    1.既然已经确定了范围，for循环
    2.起点位置-10.8应该转换成为-10，两种办法：
        ①可以使用Math.ceil方法，向上（向正方向）取整
        ②强转成为int，自动舍弃所有小数位
    3.每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
    4.如何拿到绝对值：Math.abs方法。
    5.一旦发现了一个数字，需要让计数器++进行统计。

注：如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。

方法一：使用Math.ceil方法，向上取整，double也可以进行++操作

public class MathTest {
  public static void main(String[] args) {
    // 定义最小值
    double min = ‐10.8;
    // 定义最大值
    double max = 5.9;
    // 定义变量计数
    int count = 0;
    // 范围内循环
    for (double i = Math.ceil(min); i <= max; i++) {
      // 获取绝对值并判断
      if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
        // 计数
        count++;
      }
    }
    System.out.println("个数为: " + count + " 个");
  }
}

方法二：强转成为int，自动舍弃所有小数位

public class Demo04MathPractise {
    public static void main(String[] args) {
        int count = 0; // 符合要求的数量
        double min = -10.8;
        double max = 5.9;
        // 这样处理，变量i就是区间之内所有的整数
        for (int i = (int) min; i < max; i++) {
            int abs = Math.abs(i); // 绝对值
            if (abs > 6 || abs < 2.1) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共有：" + count); // 9
    }
}

10. 继承

面向对象三大特征：封装性、继承性、多态性
继承是多态的前提，如果没有继承，就没有多态。

10.1 概述

由来
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：

在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

定义

继承 ：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

作用

1.提高代码的复用性。
2.类与类之间产生了关系，是多态的前提

。

10.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

//定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

//定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ...
}

继承演示代码：

//定义父类Employee
class Employee {
	String name; // 定义name属性    
	// 定义员工的工作方法    
	public void work() {    
		System.out.println("尽心尽力地工作");        
	}    
}

//定义子类Teacher，继承父类Employee
class Teacher extends Employee {
	// 定义一个打印name的方法    
	public void printName() {    
		System.out.println("name=" + name);        
	}    
}

//定义测试类
public class ExtendDemo01 {
	public static void main(String[] args) {    
        // 创建一个子类对象
		Teacher t = new Teacher();        
     
        // 子类Teacher当中虽然没写该成员变量，但是会继承来自父类Employee的。
		t.name = "小明";         
     
       // 调用子类的printName()方法  
		t.printName(); // name = 小明        
       
       // 调用从父类Employee继承过来的work()方法  
       t.work();  // 尽心尽力地工作  
	}    
}

10.3 继承后的特点——成员变量

10.3.1 成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
	// Fu中的成员变量。    
	int num = 5;    
}

class Zi extends Fu {
	// Zi中的成员变量    
	int num2 = 6;    
	// Zi中的成员方法    
	public void show() {    
		// 访问父类中的num，        
		System.out.println("Fu num="+num); // 继承而来，所以直接访问。        
		// 访问子类中的num2        
		System.out.println("Zi num2="+num2);        
	}    
}

class ExtendDemo02 {
	public static void main(String[] args) {    
        // 创建子类对象
		Zi z = new Zi();         
       // 调用子类中的show方法  
		z.show();          
	}    
}

演示结果：
Fu num = 5
Zi num2 = 6

10.3.2 成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu {
	// Fu中的成员变量。    
	int num = 5;    
}

class Zi extends Fu {
	// Zi中的成员变量    
	int num = 6;    
	public void show() {    
		// 访问父类中的num        
		System.out.println("Fu num=" + num); //由于重名默认访问本类的成员变量       
		// 访问子类中的num        
		System.out.println("Zi num=" + num);        
	}    
}

class ExtendsDemo03 {
	public static void main(String[] args) {    
       // 创建子类对象  
		Zi z = new Zi();         
       // 调用子类中的show方法  
		z.show();         
	}    
}

演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的 this 。
局部变量： 直接写成员变量名//局部变量
本类的成员变量： this.成员变量名//本类的成员变量
父类的成员变量： super.成员变量名//父类的成员变量

使用格式：

直接写成员变量名         //局部变量
this.本类成员变量名      //本类的成员变量
super.父类成员变量名     //父类的成员变量

子类方法需要修改，代码如下：

class Zi extends Fu {
	// Zi中的成员变量    
	int num = 6;    
	public void show() {    
		//访问父类中的num        
		System.out.println("Fu num=" + super.num);        
		//访问子类中的num        
		System.out.println("Zi num=" + this.num);        
	}    
}

演示结果：
Fu num = 5
Zi num = 6

注：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，若要访问父类的私有成员变量，可以在父类中提供公共的getXxx方法和setXxx方法。

10.4 继承后的特点——成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

10.4.1 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

class Fu{
	public void show(){    
		System.out.println("Fu类中的show方法执行");        
	}    
}

class Zi extends Fu{
	public void show2(){    
		System.out.println("Zi类中的show2方法执行");        
	}    
}

public  class ExtendsDemo04{
	public static void main(String[] args) {    
		Zi z = new Zi();        
      	//子类中没有show方法，但是可以找到父类方法去执行
      	z.show();         
		z.show2();        
	}    
}

10.4.2 成员方法重名 ——重写(Override)

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

• 重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
• 重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。代码如下：

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

class Zi extends Fu {
	//子类重写了父类的show方法    
	public void show() {    
		System.out.println("Zi show");        
	}    
}

public class ExtendsDemo05{
	public static void main(String[] args) {    
		Zi z = new Zi();        
      	// 子类中有show方法，只执行重写后的show方法   
		z.show();  // Zi show        
	}    
}

重写的应用
子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能

代码如下：

//旧版手机类
class Phone {
	public void sendMessage(){    
		System.out.println("发短信");        
}    
	public void call(){    
		System.out.println("打电话");        
}    
	public void showNum(){    
		System.out.println("来电显示号码");        
	}    
}

//智能手机类
class NewPhone extends Phone {  
	//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能    
	public void showNum(){    
		//调用父类已经存在的功能使用super        
		super.showNum();        
		//增加自己特有显示姓名和图片功能        
		System.out.println("显示来电姓名");        
		System.out.println("显示头像");        
	}    
}

public class ExtendsDemo06 {
	public static void main(String[] args) {    
       // 创建子类对象  
       NewPhone np = new NewPhone()；  
       
        // 调用父类继承而来的方法
        np.call();
     
       // 调用子类重写的方法  
       np.showNum();  
	}    
}

注：这里重写时，用到 super.父类成员方法，表示调用父类的成员方法。

注意事项

1.必须保证父子类之间方法的名称相同，参数列表也相同。

    @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
    这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2.子类方法的返回值必须小于等于父类方法的返回值范围。

    小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3.子类方法的权限必须大于等于父类方法的权限修饰符。

    小扩展提示：public > protected > (default) > private
    备注：(default)不是关键字default，而是什么都不写，留空。

4.无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

10.5 继承后的特点——构造方法

首先我们要回忆两个事情，构造方法的定义格式和作用。

• 1.构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
• 2.构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

代码如下：

class Fu {
  private int n;
  Fu(){
    System.out.println("父类构造方法！");
  }
}

class Zi extends Fu {
  Zi(){
    // super（），调用父类构造方法
    super();
    System.out.println("子类构造方法！");
  } 
}

public class ExtendsDemo07{
  public static void main (String args[]){
    Zi zi = new Zi();
  }
}

输出结果：
父类构造方法！
子类构造方法！

继承关系中，父子类构造方法的访问特点：

1.子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
2.子类构造可以通过super关键字来调用父类重载构造。
3.super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

10.6 super 和this

父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

super和this的含义
super ：代表父类的存储空间标识(可以理解为父类的引用)。
this ：代表当前对象的引用(谁调用就代表谁)。

super和this的用法
1.访问成员

this.成员变量     ‐‐    本类的   
super.成员变量     ‐‐    父类的  
this.成员方法名()   ‐‐    本类的      
super.成员方法名()   ‐‐    父类的

用法演示，代码如下：

class Animal {
    public void eat() {
        System.out.println("animal : eat");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("cat : eat");
    }
    public void eatTest() {
        this.eat();   // this  调用本类的方法
        super.eat();  // super 调用父类的方法
    }
}

public class ExtendsDemo08 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Cat c = new Cat();
        c.eatTest();
    }
}

输出结果为：
animal : eat
cat : eat
animal : eat

2.访问构造方法

this(...)     ‐‐    本类的构造方法   
super(...)    ‐‐    父类的构造方法

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

super与this的内存图

10.7 继承的特点

1.Java只支持单继承，即一个子类只能有一个直接父类。
2.Java支持多层继承(继承体系)。
3.一个父类可以拥有多个子类。

10.8 继承的综合案例

10.8.1 案例要求

群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：

• 1.群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
• 2.成员领取红包后，保存到成员余额中。

根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

10.8.2 案例分析

根据描述分析，得出如下继承体系：

10.8.3 案例实现

定义用户类：

public class User {
	// 成员变量  
    private String username; // 用户名    
    private double leftMoney; // 余额   
	// 构造方法
    public User() { }
    public User(String username, double leftMoney) {
        this.username = username;
        this.leftMoney = leftMoney;
    }
	// get/set方法    
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public double getLeftMoney() {
        return leftMoney;
    }
    public void setLeftMoney(double leftMoney) {
        this.leftMoney = leftMoney;
    }
	// 展示信息的方法    
    public void show() {
        System.out.println("用户名:"+ username +" , 余额为:" + leftMoney + "元");
    }
}

定义群主类：

public class QunZhu extends User {
	// 添加构造方法    
    public QunZhu() {
    }
    public QunZhu(String username, double leftMoney) {
		// 通过super 调用父类构造方法  
        super(username, leftMoney);
    }
	/*    
		群主发红包，就是把一个整数的金额，分层若干等份。        
		1.获取群主余额,是否够发红包.        
			不能则返回null,并提示.            
			能则继续.            
		2.修改群主余额.        
		3.拆分红包.        
			能整除的部分平分，余数分给最后一份                    
	*/    
    public ArrayList<Double> send(int money, int count) {
		// 获取群主余额  
       double leftMoney = getLeftMoney();  
       if(money > leftMoney) {
			return null;
       }
       // 修改群主余额的  
       setLeftMoney(leftMoney ‐ money);
       // 创建一个集合,保存等份金额  
       ArrayList<Double> list = new ArrayList<>();
       // 扩大100倍,相当于折算成'分'为单位,避免小数运算损失精度的问题  
       money = money * 100;
       // 每份的金额
       int m = money / count;
       // 不能整除的余数
       int n = money % count;
       // 无论是否整除,n‐1份,都是每份的等额金额  
       for (int i = 0; i < count ‐ 1; i++) {
       		// 缩小1n00倍,折算成 '元'  
            list.add(m / 100.0);
        }
        // 最后一份的金额,是之前每份金额+余数金额  
        list.add((m + n) / 100.00);
       // 返回集合  
       return list;
    }
}

定义普通成员类：

public class Member extends  User {
    public Member() {
    }
    public Member(String username, double leftMoney) {
        super(username, leftMoney);
    }
    // 打开红包,就是从集合中,随机取出一份,保存到自己的余额中
    public void openHongbao(ArrayList<Double> list) {
       // 创建Random对象  
       Random r = new Random();  
       // 随机生成一个角标  
       int index = r.nextInt(list.size());  
       // 移除一个金额
       Double money = list.remove(index);
       // 直接调用父类方法,设置到余额  
       setLeftMoney( money );
    }
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 创建一个群主对象
        QunZhu qz = new QunZhu("群主" , 200);
       
        // 创建一个键盘录入  
        Scanner sc = new Scanner();  
        System.out.println("请输入金额:");
        int money = sc.nextInt();
        System.out.println("请输入个数:");
        int count = sc.nextInt();
       
        // 发送红包   
        ArrayList<Double> sendList = s.send(money,count);
       
        // 判断,如果余额不足
        if(sendList == null){
            System.out.println(" 余额不足...");
            return;
        }
        // 创建三个成员
        Member m = new Member();
        Member m2 = new Member();
        Member m3 = new Member();
       
        // 打开红包  
        m.openHongbao(sendList);
        m2.openHongbao(sendList);
        m3.openHongbao(sendList);
		// 展示信息        
        qz.show();
        m.show();
        m2.show();
        m3.show();
    }
}

11. 抽象类

11.1 概述

由来
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

定义

• 抽象方法 ：没有方法体的方法。
• 抽象类 ：包含抽象方法的类。

11.2 abstract 使用格式

抽象方法

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体，去掉大括号，直接分号结束。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

代码举例：

public abstract void run()；

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

定义格式：

abstract class 类名字 {
 
}

代码举例：

public abstract class Animal {
    public abstract void run()；
}

抽象的使用
继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

代码举例：

public abstract class Animal {
    // 这是一个抽象方法，代表跑，但是具体怎么跑（大括号的内容）不确定。
    public abstract void run()；
}

public class Cat extends Animal {
    @Override  //用来检验对抽象方法run的重写是否正确
    public void run (){
       System.out.println("小猫在墙头走~~~")；         
    }
}

public class CatTest {
   public static void main(String[] args) {   
        // 创建子类对象
        Cat c = new Cat();  
        // 调用run方法
        c.run();
   }  
}

输出结果：
小猫在墙头走~~~

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

11.3 注意事项

1 . 不能直接创建new抽象类对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象进行使用。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2 . 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类，没有抽象方法的抽象类，也不能直接创建对象。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4 . 必须用一个子类来继承抽象父类，该子类必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

12. 接口

12.1 概述

接口就是多个类的公共规范。接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。一定要明确它并不是类，而是另外一种引用数据类型，虽然它编译生成的字节码文件仍然是：.java --> .class。

接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

12.2 定义格式

 public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

12.2.1 抽象方法

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

定义格式：

public abstract 返回值类型 方法名称(参数列表);

代码示例：

public interface InterFaceName {
    public abstract void method();
}

注意事项：

1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2.这两个关键字修饰符，可以选择性地省略。
3.方法的三要素，可以随意定义。

12.2.2 默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。

定义格式：

//默认方法
public default 返回值类型 方法名称(参数列表) {
    方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。

//静态方法
public static 返回值类型 方法名称(参数列表) {
    方法体
}

代码示例：

public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句   
    }
}

12.2.3 私有方法和私有静态方法

我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

①普通私有方法：解决多个默认方法之间重复代码问题
    格式：

private 返回值类型 方法名称(参数列表) {
    方法体
}

    代码示例：

public interface InterFaceName {
    private void method() {
        // 执行语句
    }
}

②静态私有方法：解决多个静态方法之间重复代码问题
    格式：

private static 返回值类型 方法名称(参数列表) {
    方法体
}

12.2.4 常量

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。

格式：

public static final 数据类型 常量名称 = 数据值; 
//一旦使用final关键字进行修饰，说明不可改变。

代码示例：

public interface MyInterfaceConst {
    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 12;
}

注意事项：

1.接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值；不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

12.3 基本的实现

12.3.1实现的概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

非抽象子类实现接口：

• 1.必须重写接口中所有抽象方法。
• 2.继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

class 类名 implements 接口名 {
   // 重写接口中抽象方法【必须】
   // 重写接口中默认方法【可选】  
}

12.3.2抽象方法的使用

抽象方法必须全部实现

代码举例：
定义接口：

public interface LiveAble {
    // 定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
    @Override
    public void sleep() {
        System.out.println("晚上睡");
    }
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象 
        Animal a = new Animal();
        // 调用实现后的方法
        a.eat();
        a.sleep();
    }
}

输出结果：
吃东西
晚上睡

12.3.3 默认方法的使用

接口的默认方法，可以通过接口实现类对象继承，直接调用；也可以被接口实现类进行覆盖重写。二选一，但是只能通过实现类的对象来调用。

①继承默认方法举例：
定义接口：

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
	// 继承，什么都不用写，直接调用    
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象 
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}

输出结果：
天上飞

②覆盖重写默认方法举例：
定义接口：

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void fly() {
        System.out.println("自由自在的飞");
    }
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象 
        Animal a = new Animal();
        // 调用重写方法
        a.fly();
    }
}

输出结果：
自由自在的飞

12.3.4 静态方法的使用

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。

定义接口：

public interface LiveAble {
    public static void run(){
        System.out.println("跑起来~~~");
    }
}

定义实现类：

public class Animal implements LiveAble {
	// 无法重写静态方法    
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // Animal.run(); // 【错误】无法继承方法,也无法调用
        LiveAble.run(); //只能使用接口名调用
    }
}

输出结果：
跑起来~~~

12.3.5 私有方法的使用

• 私有方法：只有默认方法可以调用。
• 私有静态方法：默认方法和静态方法可以调用。

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

定义接口：

public interface LiveAble {
    default void func(){
        func1();
        func2();
    }
    private void func1(){
        System.out.println("跑起来~~~");
    }
    private void func2(){
        System.out.println("跑起来~~~");
    }
}

12.4 接口的多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

12.4.1 实现格式

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
    // 重写接口中抽象方法【必须】
    // 重写接口中默认方法【不重名时可选】  
}
	//[ ]： 表示可选操作。

12.4.2 抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

定义多个接口：

interface A {
    public abstract void showA();
    public abstract void show();
}
interface B {
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");
    }
    @Override
    public void showB() {
        System.out.println("showB");
    }
    @Override
    public void show() {
        System.out.println("show");
    }
}

12.4.3 默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：

定义多个接口：

interface A {
    public default void methodA(){}
    public default void method(){}
}
interface B {
    public default void methodB(){}
    public default void method(){}
}

定义实现类：

public class C implements A,B{
    @Override
    public void method() {
        System.out.println("method");
    }
}

12.4.4 静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

12.4.5 优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

interface A {
    public default void methodA(){
        System.out.println("AAAAAAAAAAAA");
    }
}

定义父类：

class D {
    public void methodA(){
        System.out.println("DDDDDDDDDDDD");
    }
}

定义子类：

class C extends D implements A {
   // 未重写methodA方法  
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.methodA();
    }
}

输出结果:
DDDDDDDDDDDD

12.5 接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

代码如下：

定义父接口：

interface A {
    public default void method(){
        System.out.println("AAAAAAAAAAAAAAAAAAA");
    }
}
interface B {
    public default void method(){
        System.out.println("BBBBBBBBBBBBBBBBBBB");
    }
}

定义子接口：

interface D extends A,B{
    @Override
    public default void method() {
        System.out.println("DDDDDDDDDDDDDD");
    }
}

注意：

• 多个父接口当中的抽象方法如果重复，没关系。
• 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且必须带着default关键字。

12.6 接口的一些小结

12.6.1 接口的内容

在Java 9+版本中，接口的内容可以有：

1. 成员变量其实是常量，格式： [public] [static] [final] 数据类型 常量名称 = 数据值; 注意： 常量必须进行赋值，而且一旦赋值不能改变。 常量名称完全大写，用下划线进行分隔。

2. 接口中最重要的就是抽象方法，格式： [public] [abstract] 返回值类型 方法名称(参数列表); 注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

3. 从Java 8开始，接口里允许定义默认方法，格式： [public] default 返回值类型 方法名称(参数列表) { 方法体 } 注意：默认方法也可以被覆盖重写

4. 从Java 8开始，接口里允许定义静态方法，格式： [public] static 返回值类型 方法名称(参数列表) { 方法体 } 注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5. 从Java 9开始，接口里允许定义私有很乏，格式： 普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 } 静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }
   注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

12.6.2 注意事项

使用接口的时候，需要注意：

1. 接口是没有静态代码块或者构造方法的（当然就不能创建对象）。
2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
   格式：
   public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
   // 覆盖重写所有抽象方法
   }
3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，那么优先用父类当中的方法。

三句话
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。

13. 多态

13.1 概述

面向对象的第三大特性：封装性、继承性、多态性。

定义

多态： 是指同一行为，具有多个不同表现形式。其实就是一句话：父类引用指向子类对象。

前提【重点】

1 . 继承或者实现【二选一】
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】

13.2 多态的体现

多态体现的格式：

父类类型 变量名 = new 子类对象；
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

代码如下：

Fu f = new Zi(); // 左侧父类的引用，指向了右侧子类的对象
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
代码如下：
定义父类：

public abstract class Animal { 
    public abstract void eat(); 
} 

定义子类：

class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
} 

class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头"); 
    } 
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Animal a1 = new Cat(); 
        // 调用的是 Cat 的 eat
        a1.eat();         
        // 多态形式，创建对象
        Animal a2 = new Dog();
        // 调用的是 Dog 的 eat
        a2.eat();              
    } 
}

访问成员变量的两种方式：

1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。

成员方法的访问规则是：

       看new的是谁，就优先用谁，没有则向上找。口诀：编译看左边，运行看右边。

对比一下：

成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行却看右边。

定义父类：

public class Fu {
    int num = 10;
    public void showNum() {
        System.out.println(num);
    }
    public void method() {
        System.out.println("父类方法");
    }
    public void methodFu() {
        System.out.println("父类特有方法");
    }
}

定义子类：

public class Zi extends Fu {
    int num = 20;
    int age = 16;
    @Override
    public void showNum() {
        System.out.println(num);
    }
    @Override
    public void method() {
        System.out.println("子类方法");
    }
    public void methodZi() {
        System.out.println("子类特有方法");
    }
}

定义测试类一：

public class Demo01MultiField {
    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); // 父：10
//        System.out.println(obj.age); // 错误写法！
        System.out.println("=============");
        // 子类没有覆盖重写，就是父：10
        // 子类如果覆盖重写，就是子：20
        obj.showNum();
    }
}

定义测试类二：

public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi(); // 多态
        obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类
        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错，就更别运行了。
//        obj.methodZi(); // 错误写法！
    }
}

13.3 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

代码示例：
定义父类：

public abstract class Animal { 
    public abstract void eat(); 
} 

定义子类：

class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
} 

class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头"); 
    } 
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Animal one = new Cat(); 
        Animal two = new Dog();
        showAnimalEat(one); //吃鱼
        showAnimalEat(two); //吃骨头
    }
    public static void showAnimalEat (Animal a){
        a.eat();
    }
}

由于多态特性的支持， showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法，而且在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

13.4 引用类型转换

13.4.1 向上转型和向下转型

多态的转型分为向上转型与向下转型两种：

13.4.2 为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
转型演示，代码如下：
定义类：

abstract class Animal { 
    abstract void eat(); 
} 

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

class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头"); 
    } 
    public void watchHouse() { 
        System.out.println("看家"); 
    } 
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat(); 
        a.eat();  // 调用的是 Cat 的 eat               
        // 向下转型 
        Cat c = (Cat)a;      
        c.catchMouse();  // 调用的是 Cat 的 catchMouse        
    } 
}

13.4.3 转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat(); 
        a.eat();               // 调用的是 Cat 的 eat
        // 向下转型 
        Dog d = (Dog)a;      
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    } 
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat(); 
        a.eat();               // 调用的是 Cat 的 eat
        // 向下转型 
        if (a instanceof Cat){
            Cat c = (Cat)a;      
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;      
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
        //调用方法获得一个宠物
        //宠物可以是Cat也可以是Dog，只要属于animal就符合传参要求
        //每次传入的参数类型可以根据需要确定
        giveMeAPet(new Dog());
    } 
    //定义方法来获得一个宠物
    //它并不知道传进来的对象会是Cat还是Dog，只要是animal就行
    //但是在具体使用的时候就需要判断一下才能进行向下转换
    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

13.5 接口多态的综合案例

13.5.1 笔记本电脑

笔记本电脑（ laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。

定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。

13.5.2 案例分析

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

• USB 接口，包含开启功能、关闭功能
• 笔记本类，包含运行功能、关机功能、使用 USB设备功能
• 鼠标类，要实现 USB接口，并具备点击的方法
• 键盘类，要实现 USB接口，具备敲击的方法
  

13.5.3 案例实现

定义USB接口：

//定义接口 USB 
//省略了 [public] 关键字
interface USB {
    //由于并不确定要打开什么关闭什么，定义抽象方法 open、close
    //省略了 [public]、 [abstract] 关键字
    void open(); // 打开设备
    void close(); // 关闭设备
}

定义鼠标类：

//省略了 [public] 关键字
//鼠标就是一个USB设备
class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标开启，红灯闪一闪");
    }
    @Override
    public void close() {
        System.out.println("鼠标关闭，红灯熄灭");
    }
    public void click(){
        System.out.println("鼠标单击");
    }
}

定义键盘类：

//省略了 [public] 关键字
//键盘也是一个USB设备
class KeyBoard implements USB {
    @Override
    public void open() {
        System.out.println("键盘开启，绿灯闪一闪");
    }
    @Override
    public void close() {
        System.out.println("键盘关闭，绿灯熄灭");
    }
    public void type(){
        System.out.println("键盘打字");
    }
}

定义笔记本类：

//省略了 [public] 关键字
class Laptop {
    // 笔记本开启运行功能
    public void run() {
        System.out.println("笔记本运行");
    }
    // 笔记本使用usb设备，这时当笔记本对象调用这个功能时，必须给其传递一个符合USB规则的USB设备
    public void useUSB(USB usb) {
        // 判断是否有USB设备
        if (usb != null) {
            usb.open();
            // 向下类型转换,以便调用设备的特有方法
            if(usb instanceof Mouse){    //先判断设备是否是鼠标
                Mouse m = （Mouse）usb； //向下转型为鼠标
                m.click();  			 //调用鼠标特有方法
            }else if (usb instanceof KeyBoard){  //先判断设备是否是键盘
                KeyBoard kb = (KeyBoard)usb;     //向下转型为键盘
                kb.type();   					 //调用键盘特有方法
            }
            usb.close();
        }
    }
    public void shutDown() {
        System.out.println("笔记本关闭");
    }
}

测试类，代码如下：

public class Test {
    public static void main(String[] args) {
        // 创建笔记本实体对象
        Laptop lt = new Laptop();
        // 笔记本开启
        lt.run();
        // 创建鼠标实体对象
        Usb u = new Mouse();// 使用多态写法，直接进行向上转型
        // 笔记本使用鼠标
        lt.useUSB(u); //参数是USB类型，正好传递进去的就是USB鼠标
        // 创建键盘实体对象
        KeyBoard kb = new KeyBoard(); // 没有使用多态写法
        // 笔记本使用键盘
        // 方法参数是USB类型，传递进去的是实现类对象
        lt.useUSB(kb);// 正确写法！也发生了向上转型，kb转换为USB接口类型
        // 使用子类对象，匿名对象，也可以
//        lt.useUSB(new Keyboard()); // 也是正确写法
		
/*		类比情况：基本数据类型的自动类型转换，小-->大
        method(10.0); // 正确写法，double --> double
        method(20); // 正确写法，int --> double
        int a = 30;
        method(a); // 正确写法，int --> double
*/        
        // 笔记本关闭
        lt.shutDown();
    }
}

14. final关键字

14.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

final ： 不可改变。可以用于修饰类、方法和变量。

• 类：被修饰的类，不能被继承。
• 方法：被修饰的方法，不能被重写。
• 变量：被修饰的变量，不能被重新赋值。

14.2 使用方式

修饰类

格式如下：

final class 类名 {
 	...//方法体
}

查询 API发现像 public final class String 、 public final class Math 、 public final class Scanner等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

格式如下：

修饰符 final 返回值类型 方法名(参数列表){
    ...//方法体
}

重写被 final 修饰的方法，编译时就会报错。

修饰变量

• 局部变量——基本类型
  基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：

public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
        // 声明变量，直接赋值，使用final修饰
        final int b = 10;
        // 第二次赋值
        b = 20; // 报错,不可重新赋值
    }
}

• 局部变量——引用类型
  引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class FinalDemo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final   User u = new User();
        // 创建 另一个 User对象
        u = new User(); // 报错，指向了新的对象，地址值改变。
        // 调用setName方法
        u.setName("张三"); // 可以修改
    }
}

• 成员变量
  成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

        ①显示初始化；

public class User {
    final String USERNAME = "张三";
    private int age;
}

        ②构造方法初始化。

public class User {
    final String USERNAME ;
    private int age;
    public User(String username, int age) {
        this.USERNAME = username;
        this.age = age;
    }
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

15. 权限修饰符

15.1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限:
public ：公共的。
protected ：受保护的
default ：默认的
private ：私有的

注意事项：(default)并不是关键字“default”，而是根本不写。

15.2 不同权限的访问能力

	public	protected	(default）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用 private ，隐藏细节。
• 构造方法使用 public ，方便创建对象。
• 成员方法使用 public ，方便调用方法。

注：不加权限修饰符，其访问能力与default修饰符相同

16. 内部类

16.1 概述

什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

分类：

1. 成员内部类
2. 局部内部类（包含匿名内部类）

16.2 成员内部类

成员内部类 ：定义在类中方法外的类。

16.2.1 定义格式

class 外部类 {
    class 内部类{
    
    }
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

代码举例：

class Car { //外部类
    class Engine { //内部类
    
    }
}

16.2.2 访问特点

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，需要建立内部类的对象。

如何使用成员内部类？有两种方式：
1.间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2.直接方式，公式：

外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

访问演示，代码如下：
定义类：

// 定义外部类
public class Body { 
    // 定义成员内部类
    public class Heart { 
        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动：蹦蹦蹦！");
            System.out.println("我叫：" + name); // 正确写法！
        }
    }
    // 外部类的成员变量
    private String name;
    // 外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
        new Heart().beat();  //在外部类的方法当中，使用内部类
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

定义测试类：

public class Demo01InnerClass {
    public static void main(String[] args) {
        //间接方法
        Body body = new Body(); //创建外部类的对象
        body.methodBody(); // 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        
        //直接方法，按照公式写
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

输出结果:
心脏在跳动
心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的 .class文件，但是前面冠以外部类的类名和 $ 符号 。
比如，Person$Heart.class

16.2.3 访问同名的外部类成员变量

外部类名称.this.外部类成员变量名

在内部类中访问同名的外部类成员变量

public class Outer {
    int num = 10; // 外部类的成员变量
    public class Inner /*extends Object*/ {
        int num = 20; // 内部类的成员变量
        public void methodInner() {
            int num = 30; // 内部类方法的局部变量
            System.out.println(num); // 局部变量，就近原则
            System.out.println(this.num); // 内部类的成员变量
            System.out.println(Outer.this.num); // 外部类的成员变量
        }
    }
}

在main中定义内部类对象

public class Demo02InnerClass {
    public static void main(String[] args) {
        // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}

16.3 局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

16.3.1 定义格式

修饰符 class 外部类名称 {
    修饰符 返回值类型 外部类方法名称(参数列表) {
        class 局部内部类名称 {
            // ...
        }
    }
}

举例代码：

//外部类
class Outer {
    public void methodOuter() {
        // 局部内部类
        class Inner { 
            int num = 10;
            //局部内部类的方法methodInner()只有在methodOuter()方法内部才能调用
            public void methodInner() {
                System.out.println(num); // 10
            }
        }
        //为了在本类外调用局部内部类的方法methodInner()
        //先要在所属方法methodOuter()内创建methodInner()的对象
        //通过该对象调用局部内部类的方法methodInner()
        Inner inner = new Inner();
        inner.methodInner();
    }
}

public class DemoMain {
    public static void main(String[] args) {
        //先创建外部类对象
        Outer obj = new Outer();
        //通过该对象调用外部类的方法methodOuter() 
        //方法methodOuter()中会间接调用方法methodInner()
        obj.methodOuter();
    }
}

类的权限修饰符：public > protected > (default) > private

定义一个类的时候，可以使用的权限修饰符：

1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

16.3.2 注意事项

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的。

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：

1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class MyOuter {
    public void methodOuter() {
        int num = 10; // 所在方法的局部变量
        class MyInner {
            public void methodInner() {
                System.out.println(num); //在局部变量消失后留下的是唯一不变的两量，以便继续使用
            }
        }
    }
}

16.3.3 匿名内部类【重点】

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。

开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作:

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提

• 匿名内部类必须继承一个父类或者实现一个父接口。
• 接口的实现类（或者是父类的子类）只需要使用唯一的一次。

格式

接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};

对格式 “ new 接口名称() {…} ；” 进行解析：

1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {…}这才是匿名内部类的内容
4. 不要忘记最后的 ；

注意事项：

1. 匿名内部类，在创建对象的时候，只能使用唯一一次。
   如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
2. 匿名对象，在调用方法的时候，只能调用唯一一次。
   如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3. 匿名内部类是省略了实现类/子类名称，但是匿名对象是省略了对象名称
   强调：匿名内部类和匿名对象不是一回事！！！

使用方式
以接口为例，匿名内部类的使用，代码如下：

定义接口：

public abstract class FlyAble{
    public abstract void fly1();
    public abstract void fly2();
}

创建匿名内部类，并调用：

public class InnerDemo {
    public static void main(String[] args) {
        /*
        1.等号右边:是匿名内部类，定义并创建该接口的子类对象
        2.等号左边:是多态赋值,接口类型引用指向子类对象
        */
        //匿名内部类的使用方法
        FlyAble  f = new FlyAble(){
            @Override
            public void fly1() {
                System.out.println("飞行第一步");
            }
            @Override
            public void fly2() {
                System.out.println("飞行第二步");
            }
        };
        //调用方法,执行重写后的方法
        f.fly1();
        f.fly2();
        System.out.println("=================");

        //匿名对象的使用方法示例
        //使用了匿名内部类，而且省略了对象名称，故也可叫匿名对象!!
        new FlyAble() {
            @Override
            public void fly1() {
                System.out.println("飞行第一步");
            }
            @Override
            public void fly2() {
                System.out.println("飞行第二步");
            }
        }.fly1();
        // 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void fly1() {
                System.out.println("飞行第一步");
            }
            @Override
            public void fly2() {
                System.out.println("飞行第二步");
            }
        }.fly2();
    }
}

将匿名内部类作为参数传递
匿名内部类作为调用函数传递参数的简化用法格式：

函数名称 ( new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
        // 执行语句
    }
});

示例代码如下：

public class InnerDemo2 {
    public static void main(String[] args) {
        /*
        1.等号右边:定义并创建该接口的子类对象
        2.等号左边:是多态,接口类型引用指向子类对象
       */
       // 使用匿名内部类，但不是匿名对象，对象名称就叫 f
        FlyAble  f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
        // 将 f 传递至showFly方法中
        showFly(f);
    }
    //方法showFly的行参类型为FlyAble
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {
    public static void main(String[] args) {           
        /*
       创建匿名内部类,直接传递给showFly(FlyAble f) 
        */
        showFly( new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        });
    }
    //方法showFly的行参类型为FlyAble
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

17. 引用类型用法总结

基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。

17.1 class 作为成员变量

在定义一个类Role（游戏角色）时，可以使用 int 类型表示 角色id和生命值，使用 String 类型表示姓名。此时， String 本身就是引用类型，由于使用的方式类似常量，所以往往忽略了它是引用类型的存在。如果我们继续丰富这个类的定义，给 Role 增加武器，穿戴装备等属性，我们将如何编写呢？

定义武器类，将增加攻击能力：

class Weapon {
    private String name; // 武器名称   
    private int hurt; // 伤害值
    
    //构造方法
    public Weapon() {
    }
    public Weapon(String name, int hurt) {
        this.name = name;
        this.hurt = hurt;
    }

    //提供get/set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHurt() {
        return hurt;
    }
    public void setHurt(int hurt) {
        this.hurt = hurt;
    }
}

定义穿戴盔甲类，将增加防御能力，也就是提升生命值：

class Armour {
    private String name;// 装备名称  
    private int protect;// 防御值 
    
    //构造方法
    public Armour() {
    }
    public Armour(String name, int protect) {
        this.name = name;
        this.protect = protect;
    }

    //提供get/set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getProtect() {
        return protect;
    }
    public void setProtect(int protect) {
        this.protect = protect;
    }
}

定义角色类：

class Role {
    private int id; // 角色id  
    private int blood; // 生命值  
    private String name; // 角色名称    
    private Weapon wp;// 添加武器属性
    private Armour ar;// 添加盔甲属性

    //构造方法
    public Role() {
    }
    public Role(int id, int blood, String name, Weapon wp, Armour ar) {
        this.id = id;
        this.blood = blood;
        this.name = name;
        this.wp = wp;
        this.ar = ar;
    }
    
    // 提供get/set方法
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getBlood() {
        return blood;
    }
    public void setBlood(int blood) {
        this.blood = blood;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Weapon getWp() {
        return wp;
    }
    public void setWp(Weapon wp) {
        this.wp = wp;
    }
    public Armour getAr() {
        return ar;
    }
    public void setAr(Armour ar) {
        this.ar = ar;
    }
    
    // 攻击方法
    public void attack(){
        System.out.println(name+"使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害"+"，当前血量"+blood); 
    }
    // 穿戴盔甲
    public void wear(){
        // 增加防御,就是增加blood值
        this.blood += ar.getProtect();
        System.out.println(name+"穿上"+ar.getName()+", 生命值增加"+ar.getProtect()+"，当前血量"+blood);
    } 
}

测试类：

public class Test {
   public static void main(String[] args) {  
       // 创建Weapon 对象     
       Weapon wp = new Weapon("屠龙刀" , 110);        
       // 创建Armour 对象  
       Armour ar = new Armour("麒麟甲",120);  
       // 创建Role 对象  
       Role r = new Role();        
       
       // 为角色设置id  
       r.setId(007);   
       // 为角色设置生命值      
       r.setBlood(10000);
       // 为角色设置名称      
       r.setName("张无忌");
       
       
       // 为角色设置武器属性  
       r.setWp(wp);   
       // 为角色设置盔甲属性      
       r.setAr(ar);  
     
       // 角色进行攻击  
       r.attack();  
       // 角色穿戴盔甲
       r.wear();  
   }  
}

输出结果:
张无忌使用屠龙刀, 造成110点伤害，当前血量10000
张无忌穿上麒麟甲, 生命值增加100，当前血量10120

类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。

17.2 interface 作为成员变量

接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。所以，如果想扩展更强大技能，我们在Role 中，可以增加接口作为成员变量，来设置不同的技能。

定义接口：

// 法术攻击
public interface FaShuSkill {
    public void faShuAttack();
}

定义角色类：

public class Role {
    //创建 FaShuSkill接口类型的成员变量
    FaShuSkill fs;
    //对成员变量 fs 进行赋值
    public void setFaShuSkill(FaShuSkill fs) {
        this.fs = fs;
    }
    // 法术攻击
    public void faShuSkillAttack(){
        System.out.print("发动法术攻击:");
        fs.faShuAttack();
        System.out.println("攻击完毕");
    }
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 创建游戏角色
        Role role = new Role();
        // 设置角色法术技能
        role.setFaShuSkill(new FaShuSkill() {
        @Override
        public void faShuAttack() {
                System.out.println("纵横天下");
            }
        });
        // 发动法术攻击
        role.faShuSkillAttack();
        // 更换技能
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("逆转乾坤");
            }
        });
        // 发动法术攻击
        role.faShuSkillAttack();
	}    
}

输出结果:
发动法术攻击:纵横天下
攻击完毕
发动法术攻击:逆转乾坤
攻击完毕

我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

17.3 interface 作为方法参数和返回值类型

当接口作为方法的参数时或者返回值类型时，需要返回的其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见 List 接口作为参数或者返回值类型时，当然可以将 ArrayList 的对象进行传递或返回。

请观察如下方法：获取某集合中所有的偶数。

定义方法：

public static List<Integer> getEvenNum(List<Integer> list) {
    // 创建保存偶数的集合
    ArrayList<Integer> evenList = new ArrayList<>();
    // 遍历集合list,判断元素为偶数,就添加到evenList中
    for (int i = 0; i < list.size(); i++) {
        Integer integer = list.get(i);
        if (integer % 2 == 0) {
            evenList.add(integer);
        }
    }
    /*
   返回偶数集合 
      因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类, 
   所以evenList可以返回 
   */  
    return evenList;
}

调用方法：

public class Test {
    public static void main(String[] args) {
        // 创建ArrayList集合,并添加数字
        ArrayList<Integer> srcList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            srcList.add(i);
        }
        /*
       获取偶数集合  
       因为getEvenNum方法的参数是List,而ArrayList是List的子类,  
       所以srcList可以传递  
       */  
        List list = getEvenNum(srcList);
        System.out.println(list);
    }
}

接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。