一、IDEA的使用

1.1).常用的快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码
Ctrl+Y	删除光标所在行
Ctrl+D	复制当前行，插入光标位置的下面
Ctrl+Alt+L	格式化代码
Ctrl+/	单行注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释
Alt+Ins	自动生成代码，toString,get,set等方法
Alt+Shift+上下箭头	移动当前代码行

1.2).HelloWorld的JAVA代码书写

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

二、JAVA方法的回顾

2.1).回顾Java方法的定义格式与调用

public static void 方法名称() {
    方法体
}

方法名();

注意事项：

1.方法定义的先后顺序无所谓

2.方法定义必须是挨着的，不能在一个方法的内部定义另一个方法

三、JAVA的方法

3.1).方法

方法其实就是若干语句的功能集合

3.2).参数

参数：就是进入方法的数据

3.3).返回值

返回值：就是从方法出来的数据

3.4).定义方法的完整格式

修饰符  返回值类型 方法名称(参数类型 参数名称,....){	
	方法体
	return 返回值;
}	

修饰符，现阶段的固定写法,public static

返回值类型,也就是方法最终产生的数据结果是什么类型

方法名称，方法的名字，规则和变量一样，小驼峰

参数类型，进入方法的数据是什么类型

参数名称，进入方法的数据对应的变量名称

ps:参数如果有多个，使用逗号进行分隔

方法体：方法需要做的事情，若干行代码

return,两个作用，第一停止当前方法，第二讲后面的方绘制还给调用处

return后面的返回值，必须和方法名称前面的返回值类型，保持对应

3.5).方法的三种调用格式

a.单独调用

方法名称(参数);

b.打印调用

System.out.println(方法名称(参数));

c.赋值调用

数据类型  变量名称=方法名称(参数)

3.6）方法有参数或无参数

有参数:小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。

无参数：小括号当中留空，一个方法不需要任何数据条件，自己就能独立完成，就是无参数。

3.7)定义方法三要素

返回值类型：boolean

方法名称:isSame

参数列表:int a,int b

3.8)注意事项

a.方法应该定义在类当中，但是不能再方法当中定义方法。不能嵌套。

b.方法定义的前后顺序无所谓。

c.方法定义之后不会执行，如果希望之星，一定要调用：单独调用、打印调用、赋值调用。

d.如果方法有返回值，那么必须写上return 返回值;

e.return后面的返回值数据，必须和方法的返回值类型，对应起来。

f.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。

g.对于方法当中最后一行的return可以省略不写。

h.一个方法当中可以有多个return语句，但是必须保证同事只有一个会被执行到。

3.9）方法的重载(OverLoad)

重载：多个方法的名称一样，但参数列表不一样。

方法的重载与下列因素【有关】

a.参数的股数不同

b.参数类型不同

c.参数的多类型顺序不同

方法的重载与下列因素【无关】

a.与参数的名称无关

b.与参数的返回值无关

例子：

package day04.demo04;

/*
 * 比较两个数据是否相等
 * 参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试
 *
 * */
public class Demo02MethodOverloadSame {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame((short) 10,(short) 20));
        System.out.println(isSame(11,12));
        System.out.println(isSame(10L,10L));
    }

    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数的方法执行");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }

    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数的方法执行");
        boolean same = a == b ? true : false;
        return same;
    }

    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数的方法执行");
        return a == b;
    }

    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数的方法执行");
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }
}

println的理解

在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载

四、数组

4.1数组概念:

是一种容器，可以同时存放多个数据值。

4.2数组的特点:

a.数组是一种引用类型

b.数组当中的多个数据，类型必须统一。

c.数组的长度在程序运行期间不可改变

4.3数组的初始化

概念：在内存当中创建一个数组，并且向其中赋予一些默认值。

4.3.1两种常见的初始化方式【标准格式】：

a.动态初始化(指定长度)：直接指定数组当中的数据元素个数

//动态初始化数组格式：数据类型[] 数组名称 = new 数据类型[数组长度];
//        创建一个数组，能存放10个double类型的数据
        double[] arrayB = new double[10];

//        创建一个数组，能存放5个字符串
        String[] arrayC = new String[5];

解析含义：

左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型。

左侧的中括号：代表是一个数组。

左侧数组名称：给数组取一个名字。

右侧的new：代表创建数组的动作。

右侧的是数据类型：必须和左边的数据类型必须保持一致。

右侧中括号的长度：也就是数组当中，到底可以保存多少数据，是一个int数字。

【注意】使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下。

a.如果是整数类型：默认为0

b.如果是浮点类型：默认为0.0

c.如果是字符类型：默认为‘\u0000’

d.如果是布尔类型：默认我false

e.如果是引用类型，默认是null

b.静态初始化(指定内容)：不直接指定数据个数的多少

//静态初始化的基本格式：数据类型[] 数组名称 = new 数据类型[] {元素1,元素2, .......}
//        直接创建一个数组，里面装的全都是int数字，具体为：5、15、29
        int[] arrayA = new int[] {5,15,29,60};

//   创建一个数组，用来装字符串：“Hello”、"World"、"Java"
        String[] arrayB = new String[] {"Hello","World","Java"};

注意事项：虽然静态初始化没有直接指定长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

4.3.2静态初始化方式【省略格式】

//格式：数据类型[] 数组名称 = {元素1，元素2，...};
//        省略格式的静态初始化
        int[] arrayA = {10,20,30};

注意事项：

a.静态初始化没有直接指定长度，但仍会自动推算长度。

b.静态初始化标准格式可以拆分为两个步骤。

c.动态初始化标准格式也可以拆分为两个步骤。

d.静态初始化一旦使用省略格式，就不能拆分为两个步骤了。

//        静态初始化的标准格式，可以拆分为两个步骤
        int[] arrayB;
        arrayB = new int[]{11,21,31};
//        动态初始化的标准格式，也可以拆分为两个步骤。
        int[] arrayC;
        arrayC = new int[5];

使用建议：

如果不确定数组当中的具体内容，用动态初始化。否则，使用静态初始化。

4.3.3访问数组元素进行获取

直接打印数组名称：得到的是数组对应的，内存地址哈希值。

//        静态初始化的省略格式
        int[] array = {10, 20, 30};
        System.out.println(array);//[I@723279cf

访问数组元素的格式：数组名称[索引值]

索引值：就是一个int数字，代表数组当中元素的编号

【注意】索引值从0开始，一直到“数组的长度-1”为止。

4.4Java的内存划分（5个部分）

a.栈(stack):存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。

局部变量：方法的参数，或者是方法{}内部的变量

作用域：一旦超过作用域，立刻从栈内存当中小时。

b.堆(Heap):凡是new出来的东西，都在堆当中

堆内存里面的东西都有一个地址值：16进制

c.方法区(Method Area):存储.class相关信息，包含方法的信息。

d.本地方法栈(Native Method Stack):与操作系统相关。

e.寄存器(pc Register):与CPU相关。

4.5数组的遍历

获取数组的长度：数组名称.length

4.5.1数组的遍历

//数组的遍历：
for(int i =0; i<array.length; i++){
    System.out.println(array[i])
}

五、面向对象

5.1概念：

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为详细处理每一个细节。

面向过程：当需要实现一个功能的时候，不必关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。

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

5.2类和对象

5.2.1如何创建类：包含两个

a.属性(成员属性)

b.行为(成员方法)

public void 方法名称(){} //不需要写static

5.2.2如何使用类

a.导包：也就是支出需要使用的类，在什么位置

import 包名称.类名称;

【注意】对于和当前类属于同一个包的情况，可以省略导包语句不写。

b.创建，格式

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

Student stu = new Student();

c.使用,分为两种情况：

使用成员变量：对象名.成员变量名

stu.name 或者 stu.age

使用成员方法：对象名.成员方法名(参数)

stu.eat() 或者 stu.say()

当使用一个对象类型作为方法的【返回值】时：返回值其实就是对象的【地址值】

5.2.3局部变量和成员变量

a.定义的位置不一样【重点】

局部变量：在方法的内部

成员变量：在方法的外部，直接写在类中

b.作用的范围不一样【重点】

局部变量：只有在方法当中才可以使用，出了方法就不能再用

成员变量：整个类都可以使用

c.默认值不一样【重点】

局部变量：没有默认值，如果想要使用，必须手动赋值。

成员变量：如果没有赋值，会有默认值，规则和数组一样。

5.2.4Getter和Setter的引入

问题描述：定义person类的年龄时，无法阻止不合理的数值被设置进来。

解决方案：用private关键字将需要保护的成员变量进行修饰。

5.2.5一旦使用了private进行修饰，那么在本类中可以随意访问。但是，超出本类范围就不能【直接访问】

解决:间接访问private成员变量，就是定义一对Getter/Setter方法

命名规则：必须是setxxx或者是getxxxx来命名。

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

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

对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而Setter规则不变。【重点】

5.2.6 类的this的引入

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。如果需要访问本类房中的成员变量，需要使用格式 this.成员变量名

5.2.7类构造方法

概念：构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

格式：

public 类名称(参数类型 参数名称){
    方法体
}

【注意事项】

1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样。

2.构造方法不要写返回值类型，连void都不写。

3.构造方法不能return一个具体的返回值。

4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。

public Student(){}

5.一旦编写了至少一个构造方法，那么编译器将不再赠送。

6.构造方法也是可以进行重载的。

重载：方法名称相同，参数列表不同。

5.2.8标准类的组成部分（四个组成部分）

1.所有的成员变量都要使用private关键词修饰

2.为每一个成员变量编写一对Getter/Setter方法

3.编写一个无参数的构造方法

4.编写一个全参数的构造方法

代码：

package day04.ClassAndObject;

public class perSon {
    private String name;
    private int age;
//无参数构造函数
    public perSon() {
    }
//全参数构造函数
    public perSon(String name, int age) {
        this.name = name;
        this.age = age;
    }
//Getter
    public String getName() {
        return name;
    }
//Setter
    public void setName(String name) {
        this.name = name;
    }
    //Getter
    public int getAge() {
        return age;
    }
    //Setter
    public void setAge(int age) {
        this.age = age;
    }
}

六、JAVA_API

6.1引用类型的一般使用步骤

​ 1.导包

​ import 包路径.类名称;

​ 如果需要使用目标类，和当前类位于同一个包下，则可以省略导包语句。

​ 只有java.lang包下的内容不需要导包，其他的包都需要import语句。

​ 2.创建

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

​ 3.使用

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

6.2 Scanner类 （键盘输入）

功能：可以实现键盘输入数据，到程序当中

package Scanner;

import java.util.Scanner;

/*
* 获取键盘输入的int类型 int num = sc.nextInt();
* 获取键盘输入的String类型  String str = sc.next();
* */
public class Demo01Scanner {
    public static void main(String[] args) {
//        System.in是获取键盘输入
        Scanner sc = new Scanner(System.in);
//        获取键盘输入的int 类型
        int num = sc.nextInt();
        System.out.println("键盘输入的int类型是:"+ num);
//        获取键盘输入的String类型
        String str = sc.next();
        System.out.println("获取的键盘输入的String类型是:"+ str);

    }
}

6.3 Ramdom类 （随机数）

功能：用来生成随机数字。

使用步骤：

​ 1.导包

​ import java.until.Random

​ 2.创建

​ Random r = new Random();

​ 3.使用

​ 获取一个随机的int数字（范围是int所有范围，有正负两种）。 int num = r.nextInt();

package Random;

import java.util.Random;

public class Demo01Random {
    public static void main(String[] args) {
//        创建对象
        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            int num = r.nextInt(10) + 1 ;
            System.out.println("随机数是:"+ num);

        }

    }
}

6.4猜数字小游戏 （利用Random和Scanner）

无限次猜测 while(true)

package Random;

import java.util.Random;
import java.util.Scanner;

/*
* 猜数字小游戏实例 无限次猜测 while(true)
* 运用到Random随机数  和Scanner获取键盘输入
* */
public class Demo02RandomAndScanner {
    public static void main(String[] args) {
//        创建Random对象
        Random r = new Random();
//        获取随机数
        int randomNum =  r.nextInt(100) + 1;
//        创建Scanner对象
        Scanner sc = new Scanner(System.in);
//        利用while(true) 循环进行猜测
        while (true){
            System.out.println("请输入你猜测的数字：");
            int guessNum = sc.nextInt();
            if (guessNum > randomNum){
                System.out.println("太大了，请重试!");
            }else if(guessNum < randomNum){
                System.out.println("太小了，请重试!");
            }else{
                System.out.println("猜对了，游戏结束！");
                break;
            }

        }

    }
}

有限次猜测 for

package Random;

import java.util.Random;
import java.util.Scanner;

/*
* 猜数字小游戏实例
* 运用到Random随机数  和Scanner获取键盘输入
* */
public class Demo02RandomAndScanner {
    public static void main(String[] args) {
//        创建Random对象
        Random r = new Random();
//        获取随机数
        int randomNum =  r.nextInt(100) + 1;
//        创建Scanner对象
        Scanner sc = new Scanner(System.in);
//          利用for循环，固定猜测的次数，到了固定次数没有猜对，挑战失败
        for (int i = 0; i <= 5; i++) {
            if(i < 5){
                System.out.println("请输入你猜测的数字：");
                int guessNum = sc.nextInt();
                if (guessNum > randomNum){
                    System.out.println("太大了，请重试!");
                }else if(guessNum < randomNum){
                    System.out.println("太小了，请重试!");
                }else{
                    System.out.println("猜对了，游戏结束！");

                }
            }else{
                System.out.println("挑战失败！");
            }

        }
    }
}

6.5 ArrayList类

引入：数组的长度在程序执行的时候，不可以发生改变。

​ 但是ArratList集合的长度是可以随意变化的。

对于ArrayList来说，有一个尖括号 <e> 代表泛型。 </e>

泛型：也就是装在集合当中的所有元素，全都是统一类型的数据。

注意：泛型只能是引用类型，不是基本类型。

1.注意事项：对于ArrayList集合来说，直接打印的不是地址值，而是内容。如果内容是空，得到的是空的中括号。[ ]

package ArrayList;

import java.util.ArrayList;

public class Demo01ArrayList {
    public static void main(String[] args) {
//        从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
        ArrayList<String> list = new ArrayList<>();
//        往集合中添加数据需要用到add方法
        list.add("赵丽颖");
        System.out.println(list);

        list.add("古力娜扎");
        list.add("欧阳娜娜");
        list.add("马尔扎哈");
        System.out.println(list);
    }
}

2. ArratList 当中的常用方法

public boolean add(E e):向集合中添加元素，参数的类型和泛型一致。

public E get(int index):从集合中获取元素，参数是索引编号，返回值是对应位置的元素

public E remove(int index):从集合中删除元素，参数是索引编号，返回值是被删除的元素

public int size():获取集合的长度，返回值是集合中包含的元素个数。

package ArrayList;


import java.util.ArrayList;

public class Demo02ArrayListMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
//        add方法添加元素
        list.add("赵丽颖");
        list.add("古力娜扎");
        list.add("欧阳娜娜");
        boolean isAdd = list.add("李小璐");
        System.out.println("是否添加成功:"+isAdd);
        System.out.println(list);
//        get方法 获取元素
        String name = list.get(2);
        System.out.println("获取的元素是：" + name);
//        remove方法  删除元素
        String rename = list.remove(3);
        System.out.println("删除的人是：" + rename);
        System.out.println(list);
//        size方法  获取ArrayList的大小
        int listSize = list.size();
        System.out.println("大小是:" + listSize);
    }
}

3.遍历ArrayList

package ArrayList;

import java.util.ArrayList;

public class Demo03ArrayListEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("古力娜扎");
        list.add("欧阳娜娜");
        list.add("迪丽热巴");
        list.add("马尔扎哈");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

3.向集合ArrayList当中存储基本数据类型，必须使用基本类型对应的“包装类”

基本类型	包装类（引用类型，包装类都位于java.lang包下）
byte	Byte
short	Short
int	Integer	【特殊】
long	Long
float	Float
double	Double
char	Character	【特殊】
boolean	Boolean

package ArrayList;

import java.util.ArrayList;

public class Demo04ArrayListBasic {
    public static void main(String[] args) {
//        将Integer当做Int 类型使用
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        System.out.println(list);
        int num = list.get(1);
        System.out.println("索引值为第1号元素是：" + num);
    }
}

4.例子

1.

package ArrayList;

import java.util.ArrayList;
import java.util.Random;

/*
* 题目：生成6个1~33之间的整数，添加到集合，并遍历集合
*
* 思路:
* 1.需要储存3个数字，创建一个集合 ：<Integer>
* 2.产生随机数，用到Random
* 3.用循环6次，来产生6个随机数字，for循环
* 4.循环内调用r.nextInt(int n),参数是33,0~32  整体+1 就是 1~33
* 5.遍历集合 for,size,get
* */
public class Demo05ArrayListRandom {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33) + 1;
            list.add(num);
        }
        for (int j = 0; j < list.size(); j++) {
            System.out.println(list.get(j));
        }

    }
}

2.

package ArrayList;

import java.util.ArrayList;

/*
* 题目：自定义4个学生对象，添加到集合，并遍历
*
* 思路：
* 1.自定义一个Student类，四个部分。
* 2.创建一个集合，用来存储学生对象。泛型：<Student>
* 3.根据类，创建4个学生对象
* 4.将4个学生对象添加到集合中。 add
* 5.遍历集合： for 、size、get
* */
public class Demo06ArrayListStudent {
    public static void main(String[] args) {
//        创建一个集合
        ArrayList<Student> list = new ArrayList<>();
//          创建4个学生对象
        Student one = new Student("杨过", 21);
        Student two = new Student("小龙女", 22);
        Student three = new Student("黄药师", 23);
        Student four = new Student("老顽童", 24);
//        添加到集合
        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);
//        遍历集合
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println("姓名：" + stu.getName() + ",年龄："+stu.getAge());
        }
    }
}

3.

package ArrayList;
/*
* 题目：定义指定格式打印集合的方法(ArrayList类型作为参数),使用{}括起来，使用@符号分隔。
* 格式参照 {元素@元素@元素}
* */

import javax.lang.model.element.NestingKind;
import java.util.ArrayList;

public class Demo07ArrayListPrint {
    public static void main(String[] args) {
//        创建集合
        ArrayList<String> list = new ArrayList<>();
//        添加元素
        list.add("小鱼儿");
        list.add("花无缺");
        list.add("张无忌");
        list.add("方世玉");
        System.out.println(list); //[小鱼儿, 花无缺, 张无忌, 方世玉]
//        调用自定义方法
        printArrayList(list);

    }
    /*
    * 定义方法的三要素
    * 返回值： 只是进行打印，没有运算，没有结果，所以用void
    * 方法名称：printArrayList
    * 参数列表：ArrayList
    * */
    public static void printArrayList(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i);
            if(i == list.size() -1){
                System.out.print(name + "}");
            }else{
                System.out.print(name + "@");
            }
        }
    }
}

3.

package ArrayList;

/*
* 题目：
* 用一个大集合存入20个随机数字，然后筛选其中的元素，放到小集合中，要求使用自定义的方法实现筛选
*
* 分析：
* 1.需要创建一个大集合，用来存放int数字 <Integer>
* 2.随机数字用Random nextInt
* 3.循环20次，把随机数字放入大集合：for循环、add方法
* 4.定义一个方法，用来进行筛选
* 定义方法的三要素:
* 返回值： ArrayList小集合 (元素个数不确定)
* 方法名称：getSmallList
* 参数列表：ArrayList大集合 (装着20个随机数字)
* 5.判断是偶数，num%2==0   用if语句
* 6.如果是偶数，就放到小集合当中，否则不放
* */

import java.util.ArrayList;
import java.util.Random;

public class Demo08ArrayListReturn {
    public static void main(String[] args) {
//        创建集合对象
        ArrayList<Integer> bigList = new ArrayList<>();
//        创建随机数字对象
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;
            bigList.add(num);
        }
        ArrayList<Integer> smallList = getSmallList(bigList);
        System.out.println("偶数个数是：" + smallList.size());
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }

    }
    public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList){
//        创建一个小集合
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
            Integer num = bigList.get(i);
            if(num%2==0){
                smallList.add(num);
            }
        }
        return smallList;
    }
}

6.6字符串

java.lang.String类代表字符串

API当中表示：Java程序中的所有字符串字面值(如 “abc”)都作为此类的实现。

其实就是说：程序当只能够所有的双引号字符串，都是String类型。（就是算没有new，也照样是。）

1.字符串的特点:

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

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

​ 3.字符串效果相当于是char[]字符数组，但是底层原理是byte[]字节数组。

2.创建字符串的常见3+1种方式：

​ 三种构造方法：

​ public String(): 创建一个空白字符串，不含有任何内容。

​ public String(char[] array): 根据字符数组的内容，来创建对应的字符串。

​ public String(byte[] array): 根据字节数组的内容，来创建对应的字符串。

​ 一种直接创建：

​ String str = "hello";

package StringAPI;


public class Demo01String {
    public static void main(String[] args) {
//        使用空参构造
        String str1 = new String();
        System.out.println("第一个字符串：" + str1);

//        根据字符数组创建字符串
        char[] charArray = {'A','B','C'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串：" + str2);

//        根据字节数组创建字符串
        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println("第三个字符串："+ str3);

//        直接创建
        String str4 = "hello";
        System.out.println("第四个字符串：" + str4);
    }
}

3.字符串常量池

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

对于基本类型来说，==是进行数值的比较。

对于引用类型来说，==是进行【地址值】的比较。

package StringAPI;


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

4.字符串内容的比较 (equals)

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

a. public boolean equals(Object obj): 参数可以是任何对象，只有参数是一个字符串并且有内容相同时才会返回true,否则返回false

​ 【注意】：1.任何对象都能用Object进行接收。

​ 2.equals方法具有对称性。也就是 a.equals(b)和b.equals(a)效果一样。

​ 3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面。 推荐："abc".equals(str) 不推荐：str.equals("abc")

b. public boolean equalsIgnoreCase(String str): 忽略大小写，进行内容比较。

package StringAPI;

public class Demo03StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";

        char[] strArray = {'H','e','l','l','o'};
        String str3 = new String(strArray);

        System.out.println(str1.equals(str3)); //true
        System.out.println(str1.equalsIgnoreCase(str2));   //true
    }
}

5.与获取相关的方法

​ public int length(): 获取字符串当中含有的字符个数，拿到字符串长度。

​ public String concat(String str): 将当前字符串和参数字符串拼接成为返回值新的字符串

​ public char charAt(int index): 获取指定索引位置的单个字符。(索引从0开始)

​ public int indexOf(String str): 查找参数字符串在本字符串当中首次出现的索引位置，如果没有，返回-1值。

6.字符串截取（substring）

​ public String substring(int index): 截取从参数位置一直到字符串末尾，返回新字符串。

​ public String substring(int begin,int end): 截取从begin开始，一直到end结束，中间的字符串。 【备注】：[begin,end）包含左边，不包含右边。

7.字符串与转换相关的方法

​ public char[] toCharArray(): 将当前字符串拆分为字符数组作为返回值。

​ public byte[] getBytes(): 获得当前字符串底层的字节数组。

​ public String replace(CharSequence oldString,CharSequence newString): 将所有出现的老字符串替换成为新的字符串，返回替换之后的结果，新字符串。

package StringAPI;

public class Demo04StringConvert {
    public static void main(String[] args) {
//        toCharArray()   拆分字符串，拆分成为字符数组
        char[] chars = "hello".toCharArray();
        System.out.println(chars[0]);  //h
        System.out.println(chars.length);  //5
//          replace(oldString,newString)   替换字符串
        String str1 = "***勒，***吧！***吧！***吧！";
        String str2 = str1.replace("***", "*");
        System.out.println(str2);
    }
}

8.分割字符串（split）

​ public String[] split(String regex): 按照参数的规则，将字符串切成若干部分。

package StringAPI;

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

    }
}

9.字符串实例

1.字符串自定义拼接

package StringAPI;
/*
* 题目：
* 定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下：[word1#word2#word3]
*
* 分析：
* 1.首先准备一个int[]数组，内容是：1、2、3
* 2.定义一个方法，用来将数组变成字符串
*   定义方法的三要素：
*       返回值：String
*       方法名称：fromArrayToString
*       参数列表：int[]
* 3.格式：[word1#word2#word3]
*   用到：for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用#、区分是否为最后一个
* 4.调用方法，得到返回值，并打印结果字符串
* */

public class Demo06StringPractise {
    public static void main(String[] args) {
        int[] array1 = {1,2,3};
        String str2 = fromArrayToString(array1);
        System.out.println(str2); //[word1#word2#word3]
    }
    public static String fromArrayToString(int[] array1){
        String str = "[";
        for (int i = 0; i < array1.length; i++) {
            if(i == array1.length -1){
                str += "word" + array1[i] + "]";
            }else{
                str += "word" + array1[i] + "#";
            }
        }
        return str;
    }
}

2.统计键盘输入的各种字符的次数

package StringAPI;

/*
* 题目：
* 键盘输入一个字符串，并且统计其中各种字符出现的次数。
* 种类有：大写字母、小写字母、数字、其他字符
*
* 思路：
* 1.用到键盘输入，那么就用Scanner
* 2.键盘输入的是字符串，那么 String str = sc.next()
* 3.定义4个变量，分别代表四中字符出现的次数
* 4.需要对字符串每个字检查，String --> char[],用法的方法 toCharArray()
* 5.遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
* 6.打印输出4个变量，分别代表四种字符出现的次数。
* */

import java.util.Scanner;

public class Demo07StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();

        int countUpper = 0;
        int countLower = 0;
        int countNumber = 0;
        int countOther = 0;

        char[] array = str.toCharArray();
        for (int i = 0; i < array.length; i++) {
            char ch = array[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+"个");
    }
}

七、Static关键字

7.1 static特点

一旦用了static关键字，那么这样的内容不再属于自己，而是属于类的，所以凡是本类的对象，都共享同一份。

7.2 静态成员变量和静态成员方法

如果没有static关键字，那么首先创建对象，然后通过对象才能使用它。

如果已经有static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static.都推荐使用类名称调用。

​ 静态变量：类名称.静态变量

​ 静态方法： 类名称.静态方法()

【注意事项】：

​ 1.静态不能直接访问非静态

​ 原因：因为在内存当中是【先】有静态内容，【后】有非静态内容。“先人不知道后人，但是后人知道先人”

​ 2.静态方法中不能用this

​ 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

​ 3.根据类名称访问静态成员变量的时候

​ 全程和对象没有关系，只跟类有关系。

学生类

package StaticDemo;

public class Student {
    private int id;  //学号
    private String name; //姓名
    private int age; //年龄
    static String room;  //教室
    private static int idCounter = 0; //学号计数器

    public Student() {
        idCounter++;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

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

package StaticDemo;

public class Demo01Static {
    public static void main(String[] args) {
        Student one = new Student("曾祥连",20);
        one.room = "重庆航天职业技术学院A-2-508";
        System.out.println("姓名："+ one.getName() + "，年龄：" + one.getAge() + "，教室：" + Student.room + "，学号：" + one.getId());
        Student two = new Student("张三丰",22);
        System.out.println("姓名："+ two.getName() + "，年龄：" + two.getAge() + "，教室：" + Student.room + "，学号：" + two.getId());

    }
}

7.3 静态代码块

格式：

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

特点：当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：

​ 用来一次性的对静态成员变量进行赋值。

八、Arrays工具类

是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

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

​ public static void sort(数组),按照默认升序（从小到大）对数组的元素进行排序。

【备注】：

​ 1.如果是数值，sort默认按照升序从小到大

​ 2.如果是字符串，sort默认按照字母升序

​ 3.如果是自定义的类型，那么这个自定义的类需要Comparable或者Comparator接口的支持。

package ArraysDemo;

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

import java.util.Arrays;

public class Demo01Arrays {
    public static void main(String[] args) {
        String str = "afkhakf7failfja8cznjv";
//        进行升序排列   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.1 变量

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

9.2 重写与重载

重写（Override）:

​ 概念：在继承关系当中，方法的名称一样，参数列表【也一样】。覆盖、覆写。

【方法覆盖重写的注意事项】

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

​ @Override : 写在方法前面，用来检测是不是有效的正确覆盖重写。

​ 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

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

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

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

​ 小扩展：public > protected > (default) > private

​ 备注：(default)不是关键字，而是什么都不写，留空。

重载（Overload）:

​ 概念：在继承关系中，方法的名称一样，参数列表【不一样】。

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

9.3父子类构造方法的访问特点

​ 1.子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类的构造方法，后执行的子类构造。

​ 2.子类构造可以通过super关键字来调用父类重载构造。

​ 3.super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

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

9.4 super关键字用来访问父类内容，而this关键字用来访问本类内容

​ 1.在本类的成员方法中，访问本类的成员变量。

​ 2.在本类的成员方法中，访问本类的另一个成员方法。

​ 3.在本类的构造方法中，访问本类的另一个构造方法。

​ 在第三种用法中要注意： A：this(...)调用也必须是构造方法的第一个语句，唯一一个。

​ B: super 和this两种构造调用，不能同时使用。

9.5 Java语言是【单继承】

​ 1.一个类的直接父类只能有唯一一个。

​ 2.Java语言可以【多级继承】

​ 3.一个子类的直接父类是唯一一个，但是一个父类可以拥有很多歌子类。【二胎】

十、抽象

10.1抽象方法和抽象类

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

10.2如何使用抽象类和抽象方法

​ 1.不能直接创建new抽象类对象

​ 2.必须用一个子类来继承抽象父类。

​ 3.子类必须覆盖重写抽象父类当中所有的抽象方法。

覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后不上方法体大括号。

​ 4.创建子类对象进行使用。

10.3实现方法

概念：子类对父类抽象方法的完成实现，将这种方法重写的操作就叫实现方法。

10.4注意事项

​ 1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

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

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

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

​ 3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

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

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

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

十一、接口

接口的概念：

​ a.接口就是多个类的公共规范。

​ b.接口是一种引用数据类型，最重要的内容技术其中的：抽象方法。

11.1如何定义一个接口的格式

public interface 接口名称{
    //接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是： .java --> .class 。

Java7：接口内容包括的内容有： 1.常量 2.抽象方法

Java8：额外包括： 3.默认方法 4.静态方法

Java9 ： 额外包括：5.私有方法

11.2 在任何版本的java中，接口都能定义抽象方法

格式：

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

注意事项：

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

package MyInterface;

public interface MyInterfaceAbstract {
//    这是一个抽象方法
    public abstract void methodAbs1();
//    这也是抽象方法
    public void methodAbs2();
//    这也是抽象方法
    abstract void methodAbs3();
//    这是抽象方法
    void methodAbs4();
}

11.3接口的使用步骤

​ 1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。

​ 格式：

public class 实现类名称 implements 接口名称{		
    // .....
}

​ 2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

​ 实现：去掉abstract关键字，加上方法体大括号。

​ 3.创建实现类的对象，进行使用。

【注意事项】：如果实现类并没有覆盖冲邪恶接口中所有的抽象方法，那么这个实现类自己就必须是抽象了。

package MyInterface;
/*
这是接口
*/
public interface MyInterfaceAbstract {
//    这是一个抽象方法
    public abstract void methodAbs1();
//    这也是抽象方法
    public void methodAbs2();
//    这也是抽象方法
    abstract void methodAbs3();
//    这是抽象方法
    void methodAbs4();
}

package MyInterface;
/*
这是实现类
*/
public class MyInterfaceImpl implements MyInterfaceAbstract {
    @Override
    public void methodAbs1() {
        System.out.println("这是方法一");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是方法二");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是方法三");
    }

    @Override
    public void methodAbs4() {
        System.out.println("这是方法四");
    }
}

package MyInterface;

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

//        实现类的对象使用
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.methodAbs1(); //这是方法一
        impl.methodAbs2(); //这是方法二
    }
}

11.4接口的默认方法

默认方法的定义：

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

​ 1.接口的默认方法，可以通过接口实现类对象，直接调用。

​ 2.接口的默认方法，也可以被接口实现类进行覆盖重写。

/*
接口
*/
package Demo01Interface;

public interface MyInterfaceDefault {
    public abstract void methodA();
    public abstract void methodB();
    /*
     默认方法的定义：
     public default 返回值类型 方法名称(参数列表){
     
     }
    */
    public default void methodDefault(){
        System.out.println("这是默认方法！");
    }
}

/*
第一个实现类
*/
package Demo01Interface;

public class MyInterfaceDefaultImpl01 implements MyInterfaceDefault
{
    @Override
    public void methodA() {
        System.out.println("方法一");
    }

    @Override
    public void methodB() {
        System.out.println("方法二");
    }
}

/*
第二个实现类
*/
package Demo01Interface;

public class MyInterfaceDefaultImpl01 implements MyInterfaceDefault
{
    @Override
    public void methodA() {
        System.out.println("方法一");
    }

    @Override
    public void methodB() {
        System.out.println("方法二");
    }
}

/*
主方法
*/
package Demo01Interface;

public class Demo01Main {
    public static void main(String[] args) {
//        第一个实现类
        MyInterfaceDefaultImpl01 impl01 = new MyInterfaceDefaultImpl01();
        impl01.methodA(); //方法一
        impl01.methodDefault(); //这是默认方法！
        System.out.println("===============");
//        第二个实现类
        MyInterfaceDefault02 impl02 = new MyInterfaceDefault02();
        impl02.methodA();  //方法一
        impl02.methodDefault(); //覆盖重写了接口的默认方法

    }
}

11.5接口小总结

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

​ 1.成员变量其实是常量，格式：

[public] [static] [final] 数据类型 常量名称 = 数据值;

​ 注意： a.常量必须进行复制，而且一旦复制不能改变。

​ b.常量名称完全大写，用下划线进行分隔。

​ 2.接口中最重要的就是抽象方法，格式

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

​ 注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

​ 3.从Java 8开始，接口里允许定义默认方法，格式：

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

​ 注意：默认方法也可以被覆盖重写。

​ 4.从Java 8开始，接口里允许定义鼎泰方法。格式：

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

​ 注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。

​ 5.从Java 9开始，接口里允许定义私有方法。格式：

//普通私有方法
private 返回值类型 方法名称(参数列表){
    //方法体
}
//静态私有方法
private static 返回值类型 方法名称(参数列表){
    //方法体
}

​ 注意：private 的方法只有接口自己才能调用，不能被实现类或者别人使用。

11.6 实现多个接口

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

​ 1.接口是没有静态代码块或者构造方法的。

​ 2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式：

public class 类名称 implements 接口一,接口二{
    //覆盖重写所有抽象方法
}

​ 3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

​ 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类必须是一个抽象类。

​ 5.如果实现类在实现多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

​ 6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

11.7接口之间的继承

​ 1.类与类之间是单继承的。直接父类只有一个。

​ 2.类与接口之间是多实现的。一个类可以实现多个接口。

​ 3.接口与接口之间是多继承的。

【注意事项】：

​ 1.多个父接口当中的抽象方法如果重复，没关系。

​ 2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】

十二、多态

12.1概念：

​ 多态是同一个行为具有多个不同表现形式或形态的能力。

​ 多态就是同一个接口，使用不同的实例而执行不同操作，如图：

​ 代码当中体现多态性，其实就是，父类引用指向子类。

格式：

父类名称 对象名 = new 子类名称();
//或者
接口名称 对象名 = new 实现类名称();

12.2访问成员变量的两种方式和访问成员方法的规则

【成员变量】：

​ 1.【直接】通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。

​ 2.【间接】通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上查找。

【成员方法】：

​ 在多态的代码当中，成员方法的访问规则是：

​ 看new的是谁，就优先用谁，没有则向上找。

【总结】：

成员方法：编译看左边，运行还看左边。

成员方法：编译看左边，运行看右边。

12.3多态的写法

package Demo01;

public class Demo01Main {
    public static void main(String[] args) {
//        如果不用多态，只用子类的写法
        Teacher one = new Teacher();
        one.work();//讲课
        Assistant two = new Assistant();
        two.work();

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

//        如果使用多态，那么写法是：
        Person three = new Teacher();
        three.work(); //讲课
        Person four = new Assistant();
        four.work(); //辅导
    }
}

12.4对象的向上转型

对象的向上转型，其实就是多态写法：

//格式
父类名称 对象名 = new 子类名称();

​ 含义：右侧创建一个子类对象，把它当做父类来看待使用。

​ 注意事项：向上转型一定是安全的。从小范围转向大范围，从小范围的猫，向上转换成为更大范围的动物。

Animal animal = new Cat(); //创建了一直猫，当做动物看待

12.5对象的向下转型

​ 对象的乡下转型，其实是一个【还原】的动作。

//格式
子类名称 对象名 = (子类名称)父类对象

​ 含义：将父类对象，【还原】成为本来的子类对象。

Animal animal = new Cat();//本来是猫，向上转型成为动物
Cat cat = (Cat)animal; //本来是猫，已经被当成动物，还原回来成为本来的猫

注意事项：

​ a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫

​ b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

十三、final

final关键字代表最终，不可改变的。

常见的四种用法：

1.可以用来修饰一个类。

​ 当final关键字修饰一个类的时候，格式

public final class 类名称{
    //...
}

2.可以用来修饰一个方法

​ 当final关键字修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写

格式：

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

3.还可以用来修饰一个局部变量

​ 一旦使用final用来修饰局部变量，那么这个变量就不嗯能够进行更改。

​ “一次赋值，终身不变”

4.还可以用来修饰一个成员变量

​ 对于成员变量来说，如果使用了final关键字修饰，那么这个变量也照样是不可变。

​ 1.由于成员变量就有默认值，所以用了final之后必须手动赋值，不会再给默认值了。

​ 2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。

​ 3.必须保证当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

十四、Java中的四种修饰符

public	protected	(default)	private
同一个类(我自己)	yes	yes	yes	yes
同一个包(我邻居)	yes	yes	yes	no
不同包子类(我儿子)	yes	yes	no	no
不同包非子类(陌生人)	yes	no	no	no

【注意事项】：(default)并不是关键字"default",而是根本不写。

十五、内部类

如果一个十五的内部包含另一个十五，那么这就是一个类内部包含另一个类。

分类：

15.1.成员内部类

成员内部类的定义格式：

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        //....
    }
    //.....
}

注意：内用外，随意访问；外用内，需要内部类对象。

15.1.1如何使用成员内部类？有两种方式：

​ 1.间接方式： 在外部类的方法当中，使用内部类，然后main只是调用外部类的方法。

​ 2.直接方式：公式：

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

15.1.2如果出现【重名现象】，那么格式是：外部类名称.this.外部类成员变量名

12.2.局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

“局部”：只有当前所属的方法才能使用它，除了这个方法外面就不能用了。

定义格式：

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

12.2.1内部类中的权限修饰符

public > protected >(default) >private

定义一个类的时候，权限修饰符规则

​ 1.外部类：public /(default)

​ 2.成员内部类：public / protected / (default) / private

​ 3.局部内部类：什么都不写

12.3局部内部类

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

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

原因：

​ 1.new出来的对象在堆内存当中。

​ 2.局部变量是跟着方法走的，在栈内存当中。

​ 3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。

​ 4.但是new出来的对象会在堆内存当中持续存在，直到垃圾回收消失。

12.4匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：

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

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

​ 1.new 代表创建对象的动作

​ 2.接口名称就是匿名内部类需要实现哪个接口。

​ 3.{...}这才是匿名内部类的内容

另外还要注意几点问题：

​ 1.匿名内部类，在【创建对象】的时候，只能使用唯一一次。

​ 如果希望多次创建对象，而且类的内容一样的话，那么久必须使用单独定义的实现类了。

​ 2.匿名对象，在【调用方法】的时候，只能调用唯一一次。

​ 如果希望同一个对象，调用多次方法，那么必须给对象起个名字。

​ 3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

强调：匿名内部类和匿名对象不是一回事。

十六、File类

file类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法。

三个单词：

​ file 文件

​ directory 目录

​ path 路径

16.1分隔符

方法：

​ public String pathSeparator 路径分隔符 windows分号 ; Linux:冒号 :

​ public String separator 默认名称分隔符

16.2 file类的构造方法

a. File(String pathname) 通过将给定路径名字字符串转换为抽象路径名来创建一个新file实例。

​ 参数：

​ String pathname：字符串的路径名称

​ 路径可以是以文件结尾，也可以是以文件夹结尾。

​ 路径可以是相对路径，也可以是绝对路径

​ 路径可以是存在，也可以是不存在

​ 创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况。

b. File(File parent, String child) 根据parent抽象路径名和 child路径名字符串创建一个新File实例。

​ 参数：分成了两个部分

​ File parent: 父路径

​ String child:子路径

​ 好处：

​ 父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化。

​ 父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象。

16.3 File类获取功能的方法

​ public String getAbsolutePath() :返回此File的绝对路径名字符串

​ public String getPath() :将此File转换为路径字符串。

​ public String getName() :返回由此File表示的文件或目录的名称

​ public Long length() :返回由此File表示的文件的长度

16.4判断功能的方法

​ public boolean exists() :此File表示的文件或目录是否实际存在

​ public boolean isDirectory() :此File表示的是否为目录

​ public boolean isFile() :此File表示的是否为文件

16.5创建删除功能的方法

​ public boolean createNewFile() :当且仅当具有该名称的文件上不存在时，创建一个新的空文件。

​ public boolean delete() :删除由此File表示的文件或目录

​ public boolean mkdir() : 创建由此File表示的目录

​ public booean mkdirs() : 创建由此File表示的目录，包括任何必须但不存在的父目录。

16.6遍历（文件夹）目录的功能

​ public String[] list() : 返回一个String数组，表示该File目录中的所有子文件或目录

​ public File[] listFiles() : 返回一个File数组，表示该File目录中的所有子文件或目录

【注意】：

​ list方法和listFiles方法遍历的是构造方法中给出的目录

​ 如果构造方法中给出的目录的路径不存在，会抛出空指针异常

​ 如果构造方法中给出的路径不是一个目录，也会抛出空指针异常。