一、IDEA的使用

1.1).常用的快捷键

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来说，有一个尖括号代表泛型。

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

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

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当中存储基本数据类型，必须使用基本类型对应的“包装类”

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 变量

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中的四种修饰符

【注意事项】：(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方法遍历的是构造方法中给出的目录

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

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

Java基础

原文：https://www.cnblogs.com/KingTL/p/12945262.html