Java复习指南

在开篇前首先申明一下，本文虽不够系统，但复习够用，尤其是快速回忆( •̀ ω •́ )✧与提问。
主打一个速度。
本文将会从Java的基础语法、面向对象、API、字符串、集合、进阶…等六方面讲起。

一、Java的基础语法：

1、Java入门

JRE和JDK

JDK：分为三大类：Jvm(虚拟机)、核心类库，开发工具；

核心类库：javac编译工具；java运行工具；jdb调试工具；jhat内存分析工具；

JRE:运行工具；

备注：

单行备注( // )；多行备注( /* */ )；文档备注( /** */ )；        

2、小概念

public class HelloWorld{}
// class: 用于(创建/定义)一个类，类是Java最基本的组成单元

包：

包 (package) 是组织类的一种方式。使用包的主要目的是保证类的唯一性

类与对象：

所谓对象，就是类产生的一个实体。

例如：盖房子的图纸就是java类，根据这个图纸修建起来的能够被看到的就相当于对象。java类实际是一个抽象意义上的概念，对象就是通过这个Java类的抽象概念具体化之后的的具体的一个概念。

总结：
1、java类是构成对象的模板。
2、对象就是这个模板的具现后的具体现实。

关键字

被Java赋予了特定含义的英文单词；（class关键字,后面跟随类名）

变量：

整数变量，小数变量。（这两个能直接写在System.out.println()后的()中，如(1),(1.900)等等）
字串类型（" "），字符类型(' ')。
布尔类型(true false)，空类型(null,但在输入空类型时，需要加字符串如" " )。
一般用boolean类型时，不要用==号（例：boolean a=true；if(a)…就可以运行。）

成员变量：

成员变量、类中方法外。

局部变量：

局部变量、类中方法内。

储存方式：

二进制：由0和1组成，代码以0b开头。八进制：以0开头，16进制以0x开头

任意进制转化为10进制。公式：系数*基的权次幂 相加（）
系数：就是每一位上的数；
基数：当前进制数；
权：从左往右依次为0、1、2…..|| （例如：101转化为 1*2^0+0*2^1+1*2^2;）

十进制转其他进制：除基取余法。

标识符：

首先说明，不按规则命名或许不错，但这样就像有些人偷看美女一样，猥琐。所以为了正常，就要接受命名规则—软性建议

小驼峰命名法：方法、变量—> 规范1：标志符是一个单词时，全部小写(name)。规范2：标识符有多个单词组成时，第一个单词首字母小写，其他单词首字母大写(firstname)。

大驼峰命名法：类名 —->规范1：标识符是一个单词时，首字母大写。 规范2：标识符有多个单词组成时，每个单词首字母多大写。

注意！！ 命名时，有一个潜在规则，就是见名知义。

键盘录入:

java帮我们写好了一个类叫Scanner，这个类就可以接收键盘输入的数字。（英文scanner:秒扫仪）

// 步骤一：导包---导包的动作必须在类定义的前面：
import java.util.Scanner;
// 步骤二：创建对象--表示要开始使用Scanner这个类了
Scanner sc = new Scanner(System.in);
// 步骤三：接受数据--真正开始干活
int i = sc.nextInt();

键盘录入的另一种方法：

拓展next():

第一套体系：

nextInt()

接收整数

nextDouble()

接收小数

next()

接受字符串，遇到空格、Tab键，回车就会停止。

第二套体系：

nextLine() —> （会接收一行）。无视空格和Tab。

3、idea

在idea中编程的前提：

首先：新建project(项目) 其次：module(模块)

然后：在模块中创建package(包) 最终：在src中创建class(类)

运算符

先说一下运算符的总和：

算术运算符

关系运算符

位运算符

逻辑运算符

赋值运算符

其他运算符

运算符详解–网页，可以详解

1、算术运算符

–与c几乎无异。注意%(取余，取模)

注意：mod就是取模的意思。

–在进行带小数点运算时，与c无异的是结果都有可能不精确。

–隐式转换(自动类型提升)与c无异：范围为byte->short->int->long->float->double

—注意：byte short char 三种类型的数据在运算的时候，都会直接提升为int，然后在进行运算。

–强制转换(与c大致相同)：目标函数类型 变量名=（目标数据类型）被强转的类型；

–算数运算符“+”的操作(与c有大不同)：具体介绍是他有时比c根方便，不用putchar()而用“ ”就能把字符串输入；例：“a:”+1.1+2.3//输出为a:1.12.3 但是1.1+2.3+“a:”//输出3.4a：

—当字符+字符||字符+数字时，会把字符通过ASCLL码表查询到对应的数字在进行计算。

System.out.println(1+'a');// 结果为98 System.out.println('a'+"abc");//结果为aabc，有字符串时就不符合规则了。

2、自增自减运算符

++，–等与c几乎无异；

3、赋值运算符(与c无异)

4、关系运算符(与c无异)

5、逻辑运算符(与c差别不大)

&–>逻辑与(且)： 并且，两边都为真，结果才真。 |–>逻辑或：或者，两边都为假，才假

^—>逻辑异或： 两边相同为false，不同为true。 !–>逻辑非：取反

System.out.println(true^true); // false
System.out.Println(false^true); // true
System.out.println(!false);//true--一般用逻辑非，"!"要么用一个，要么不用。

6、三元运算符(与c无异)

一元：如a++，整个式子只有一个变量(操作数)，如a
二元：a+b，有两个操作数。a和 b
三元格式，关系表达式？表达式1：表达式2；
在此有一感受就是java有时开放性，大于c;(暂时是这么认为)–大一 ·上

import java.util.Scanner;
public class day3{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        System.out.println("请输入第一只:"+a);
        int b=sc.nextInt();
        System.out.println("请输入第二只："+b);
        String c=a==b?"相同":"不同";
        System.out.println(c);//结果是相同
    }
}

7、运算符优先级

8、原码、反码、补码

原码：十进制数据的二进制表现形式，最左边是符号位，0为正，1为负

原码弊端：利用原码进行计算时，如果是正数完全没问题。但是如果是负数，结果就出错，实际的运算的方向，根正确的运算方向相反

反码：为了解决原码不能计算负数的问题而出现的。

反码计算规则：正数反码不变，负数的反码在原码的基础上，符号位不变。数值取反，0变1，1变。

反码的弊端：负数运算的时候，如过结果跨0，跟实际结果就会有1的偏差。

补码出现的目的：为了解决负数计算时跨0的问题而出现的。

补码的计算规则：正数的补码不变，负数的补码在反码的基础上+1。另外补码还能多记录一个特殊的值-128，该数在一个字节(8个bite位)下，没有原码和反码。

补码的注意点：计算机的储存和计算都是以补码的形式存在的。

public class day3{
    public static void main(String[] args){
        int a=200;//0000 0000 1100 1000
        byte b=(byte)a;//1100 1000
        System.out.println(b);//并且在计算机负数的储存都是补码，要取反加 1。
    }
}

9、基本数据类型在计算机中的储存

数据类型所占字节默认值：

更加详细如下：

四类八种：

引用数据类型：

类、数组、接口、String字符串…..等等

10、其他运算符(可能我c只学了入门级别的，我暂时未在c中见到这)

格式依次为：运算符->含义->运算规则

&： 逻辑与 0为false 1为true
|: 逻辑或 0为false 1为true
>>：右移 向右移动，高位补0或1
>>>:无符号右移 向右移动，最高位补0

(1)、在&和 | 中，运算规则(暂时不知道有啥用，可能还没学到，并且我在c中没学到这个)：

&是上下(对位处)都为1时，才是1。 而 | 只要上下有一个就会是1。

(2)、>和 >>>他们的计算规则为

>>中补的0或1中，1是符号位。在有一规则向右移一位

4、判断和循环

循环

1、顺序结构

流程控制语句，计算机就是从上到下依次解读翻译的

2、分支结构

if(与c几乎无差异)

if(关系表达式1){
    语句体1;
}else if(关系表达式2){
    语句体2;
}
...
else {
    语句体 n+1;
}

switch (在c大体上相同，只在简写的地方不同)

switch(表达式){
    case 值1：
        语句体1;
        break;
    case 值2：
        ... ...
     default：
         语句体n+1;
         break;                                 
}

switch其他知识点(1、2 与c还差不多，3大大不同)    

1、default（无论写到这个循环的哪个空位置都会发挥其作用，哪怕是两个case判断题之间，平时是为了美观）
2、case的穿透，必须要用break阻止。
3、switch的新特性(不过我试过了，我这个idea版本不能用这个办法)：

int number=1;
switch (number){ 
    case 1-> System.out.println("一");
    case 2-> System.out.println("二");
    case 3-> System.out.println("三");
    case 4-> System.out.println("四");
    default -> System.out.println("没有这种选择");
}//注意：这是idea新版本的用法，其他版本的不一定支持。

3、循环结构

while循环

while

格式：
初始化语句
while(条件判断语句){
    循环体语句；
    条件控制语句；
}

do while

格式：
初始化语句
do{
    循环体语句；
    条件控制语句；
}while(条件判断语句);

for循环

for循环有两种格式，

第一种：for( ; ; 😉

第二种：foreach语句与数组

//for(type element: array)
//for(int i : arr)
就相当于对这个数组循环一遍，从i开始，到最后。

for与while对比：

相同点

运行规则都是一样的

for与while的区别

其一

for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了

while循环中，控制循环的变量，对于while循环来说是不归属其算法结构中，在循环结束后，该变量还可以继续使用

其二

for循环中：知道循环的次数；

while循环：不知道循环的次数和范围，只知道循环的结束条件。

无限循环：

如：for( ; ; ;);
但是for(int i=0; i<0; ++i); // 这玩意，是一次循环都进入不了

条件控制语句：

continue：跳过本次循环，继续执行下次循环。
break：结束整个循环。

loop:while（true）{
break loop;}
这两个是一起使用的，用于跳出整个循环。
可以跳出多个循环，而loop有两点应用，
one：是在要跳出的循环的前面如本题while。
two：loop只是一个起标记作用的标志，也能用其他英文标志，如aaa等….

System.exit(0);

在java循环中，应用System.exit(0)表示整个程序直接结束。

扩展 · 随机数（）

获取随机数：java帮我们写好了一个类叫Random，这个类就可以生成一个随机数。

使用步骤：

/导包 -- Random这个类在哪
imprt java.util.Random;//导包的动作必须出现在类定义的上边
//创建对象 -- 表示我要开始用Random这个类了
Random r=new Random();//上面这个表格里面，只有r是变量名，可以变，其他的都不允许
//生成随机数 --- 真正开始干活了
int number = r.nextInt(bound:随机数的范围);//上面这个格式里面，只有number是变量名，可变，其他都不行
//切记，bound后面的数，为范围 : [0~(bound-1)]
/*
在学完创建对象(类与对象)后，在根据栈与堆的应用、“.”的作用，我明白了
为什么要用“r.nextInt()”且为什么还要加“.” ，new在堆中创建了新空间，
并把地址传给了r。而“.”的作用就是进入某个地址，r.就是进入了new所创建的
新地址，然后将找到的值穿给number。
*/

与c区别：

c中也要做类似

于导包的动作，是#include

然后下面才能用 rand();

其中#include是编译预处理指令，他的含义是让编译程序在头文件目录中搜索指定名称的头文件并将其插入到指令所在的位置。

5、方法

什么是方法

方法（method）是程序中最小的执行单元。
定义：把一些代码打包放在一起，改过程称之为方法。

实际开发中什么时候用到方法？

重复的代码、具有独立功能的代码可以抽取到方法中。

实际开发中，方法有什么好处？

可以提高代码的复用性，提高可维护性、

方法的重载

在同一个类中，方法名相同，参数不同，与返回值无关；

参数不同：个数不同、类型不同、顺序不同。

方法的格式

//当有多个参数时
public class void sum(int number1,int number2....)

形参和实参

形参：全称形式参数，全称方法定义中的参数。
实参：全称实际参数，方法调用中的参数。

带方法的返回值

public static 返回值类型 方法名 (参数){
    方法体;
    return 返回值;
}

方法的内存 

方法调用的基本内存原理

从main函数开始，一次将方法放入栈中。

方法传递 基本数据类型 的内存原理

基本数据类型：整数类型，浮点数类型，布尔类型，字符类型

方法传递 引用数据类型 的内存原理

引用数据类型：除基本数据类型的其他所用类型

6、数组

一、一维数组：

数组介绍

数组指的是一种容器，可以用来储存同种数据类型的多个值

例如：int类型的数组容器（boolean不可以 byte short int double不可以 ）

例如：double类型的数组容器（byte short int long float double)(不划线的都是可以写入数组)

建议：容器的类型，和储存的数据类型保持一致。

数组的定义与静态初始化

格式一：数据类型[ ] 数组名—–>范例：int[ ] array

格式二：数据类型 数组名 [ ]——> int arry [ ]

一般默认推荐使用格式一。

初始化：

静态初始化：

就是在内存中，为数组容器开辟空间，并将数据存入容器的过程。

//完整格式：数据类型[] 数组名=new 数据类型[] {元素1，元素2，元素3....}
int[] array = new int[]{11,22,33};
double[] array2 = new double[]{11.1,22.2,33.3};

数组的地址值：
int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@5d03e736
//[:表示当前是一个数组；
//D:表示当前数组里面的元素都是double类型的
//@:表示一个间隔符号。(固定格式)
//5d03e736：才是数组真正的地址值(16进制)
//平时我们会习惯性的把整体叫做地址值

索引：

索引也叫下标，角标。

特点：从0开始，逐个加1，连续不断；

动态初始化：

（如下）
（暂时有些难，会托后面一点讲）

数据遍历

遍历：将数组所有的能容取出来，取出来后可以（打印，求和，判断…）
注意：便历指的是取出数据的过程，不要局限的理解为，便历就是打印。

数据动态初始化

动态初始化：初始化只能指定数组长度，由系统为数组分配初始值
格式：数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ]
范例：int [ ] arr = new int[3]

与静态的区别

动态

手动输入数组长度，由系统给出默认值。

只明确元素个数，不明确具体数值，推荐使用动态初始化

//使用数组容器来储存键盘录入的5个整数。
int [] arr ={??????};
int [] arr =new int[5];

静态

手动指定数组元素，系统会根据元素个数，计算出数组的长度

已经明确了操作的具体数据，直接静态初始化即可。

int[] arr={11,22,33};

数组常见操作

求最值

//定义max变量准备记录擂台上的变化
int max = arr[0];
//便利数组获得每一个元素
for(int i=1;i<arr.length;i++){
    arr[i];
}
//让每一个元素跟max进行比较，如果找到更大的就让max记录该元素
for(int i=1;i<arr.length;i++){
    if(arr[i]>max){
        max = arr[i];    
    }
}

求和

交互数据

for(int i=0,j=arr.length-1;i<j;i++,j--){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp;
}

打乱数据

二、二维数组：

（1）、二维数组静态初始化：

格式：数据类型[][] 数组名 = new 数据类型[][]{ {元素1，元素2} , { 元素1，元素2} }

范例：int[][] arr = new int[][]{ {11,22},{33,44} }

简化格式：数据类型[][] arr = { {元素1，元素2} , { 元素1，元素2} }

一般就推荐这种，是因为阿里巴巴代码规范中，就是这么规范的。

（2）、二维数组的动态初始化：

格式：数据类型[][] 数组名 = new 数据类型[m][n];

m表示这个二维数组，可以存放多少个一维数组；

n表示这个二维数组，可以存放多少个元素；

范例：int[][] arr = new int[2][3];

存放两个一维数组，每个数组可以存放3个int类型元素；

二维数组中两个特殊操作：

1：

public static void main(String[] args){
    int[][] arr = new int[2][];
    int[] arr1 = {11,22};
    int[] arr2 = {33,44,55};
    arr[0] = arr1;
    arr[1] = arr2;
}

配图解释如下：        

2：初始化方式

public static void main(String[] args){
    int[][] arr = new int[2][3];
    int[] a1=new int[]{11,22};
    int[] a2=new int[]{33,44,55};
    arr[0] = a1;
    arr[1] = a2;
}

拓展：

数组的长度属性

a=arr.length,其中a为长度

Java的内存分配：

1、栈

方法运行时使用的内存。

比如main方法运行

进入方法栈中执行

2、堆

new来创建的

都储存在堆内存

但两个数组指向同一个小空间时，其中一个数组对空间的值发生改变，那么其他数组再次访问的时候都是修改过的值。

这才是栈和堆的真正用法

3、方法区

存储可以运行的class文件

4、本地方法栈

JVM在使用操作系统功能的时候使用，和我们开发无关

5、寄存器

给CPU使用，和我们开发无关

二、面向对象

1、类和对象：

类（设计图）：是对对象共同特征的描述。

对象：是真实存在的具体东西；

在java中，必须先设计类，才能获取对象。

//---->类：
public class 类名{
    1、成员变量（代表属性，一般是名词）
    2、成员方法（代表行为，一般是动作）
    3、构造器（后面学习）
    4、代码块（后面学习）
    5、内部类（后面学习）
}
//---->实例：
public class Phone{
    //属性（成员变量）
    String brand;
    double price;
    //行为（方法）
    public void call(){            
    }
    public void playGame(){            
    }
}

2、如何得到类的对象：

就相当于 ——> 创建对象

类名 对象 = new 类名()；
Phone p = new Phone()；

3、如何使用对象：

访问属性：对象名.成员变量

访问行为：对象名.方法名(….)

4、补充：

(定义类的补充注意事项)

用来描述一类事物的类，专业叫做：javabean类。

在javabean类中，是不写main方法的。

在以前编写main方法的类，叫做测试类。

我们可以在测试类中创建Javabean类的对象并进行赋值调用。

在一个java文件中可以定义多个class类，且只能有一个类是public修饰的，而且public修饰的类名，必须成为代码文件名。

实际开发中，还是建议一个文件只定义一个class类。

成员变量的完整格式是：修饰符 数据类型 变量名称 = 初始化；

面向对象的三大特征

封装

封装告诉我们，如何正确的设计属性和方法。

对象代表什么，就得封装对应的数据，并提供数据对应的行为。

告诉我们如何正确设计对象的属性和方法。

封装扩展之包：为了更好的管理项目，把多个类收集到一起组成一组，称为软件包。通俗的说就是文件夹。

        好处： 让编程变得更简单，有什么事，找对象，调方法。

        降低学习成本，可以少学、少记。不用记对象有哪些方法，有需要去找就行。

        将不需要对外界提供的内容和属性都隐藏起来，提供公共方法对其访问。

继承

多态

面向对象的思想

java是一个面向对象的程序程序设计的语言，在程序中使用对象来描述具体的事物，当多个事物具有共同的特点时，可以将事物的共同特点提取出来，进行抽象，让后封装成一个包含事物共同特征的集合。

Java语言的特性

1、private关键字

是一个权限修饰符。

可以修饰成员（成员变量和方法）。

被private修饰的变量只能在本类中才能被修饰访问。

针对private成员变量，如果需要被其他服务类使用，提供相用的操作。如下

public class GirlFriend{
    private int age;
    //set(赋值)
    public void setAge(int a){
        if(a>=18&&a<=50)
            age = a;
        else
            System.out.println("非法数据");
    }
    //get(获取)
    public int getAge(){
        return age;    
    }
}

可变参数

java中，我们把名称相同，功能也相同，但是形参个数不同的多个函数封装到一个函数。
比如：要求多个个数的和，但是此时并不确定一共要求几个数，如果形参每变化一次，就要有一个新的函数，那我们效率就会大打折扣，于是出现了–>可变参数；

格式：

返回值类型 方法名(固定参数列表，数据类型... 可变参数名){
    方法体
}

2、this关键字

就近原则

System.out.println(age);
System.out.println(age);

this的作用

可以区分_成员变量 和_局部变量。
public void setName(String name){ //等号左边：就是成员变量位置的name。
this.name = name; //局部变量表示测试类中调用方法传过来的数据。

3、构造方法

构造方法能完成创建对象时的初始化。在一个类中，要同时定义有参和无参的构造方法。因为定义有参的构造方法时，电脑就无法默认生成无参的构造方法。构造方法一般是由new调用的。（在创造对象时，虚拟机会自动调用构造方法，目的是给成员变量进行赋值）

格式：修饰符 类名(参数)

{ 方法体 }；

public class StudentDemo{
public static void main(String[] args){
    Student s1 = new Student();
    }
}

构造方法有两种

有参构造：初始化对象时，对成员变量直接赋值

无参构造：初始化对象时，成员直接使用默认值

建议有参、无参一起写

4、标准JavaBean

什么是：是用Java语言写成的可重用的组件。

Bean是java可从重用软件组件的习惯叫法。

1、必须有驼峰命名法，见名知意。
2、必许有private关键字
3、同时用有参和无参两种构造方法。
4、成员方法：每一个成员变量都至少提供对应的：setXxx()/getXxx()

5、对象内存图

Java内存分配介绍：堆、栈、方法区。

先后顺序为：字节码加载进入方法区–>方法运行时进入栈内存(包括变量)–>new出来时进入堆内存，开辟空间产生地址 同时将堆内存传给左边的局部变量

加载.class文件 –> 申请局部变量 –> 在堆内开辟空间 –> 默认，显示初始化，构造方法初始化 — > 将堆中的地址值赋给左边的局部变量 

6、this的内存

作用：区分成员变量和局部变量。 本质：所在方法调用者的地址值。

例：this.name = name。其实就是this知道name作为成员变量时的地址值。

成员变量：类中方法外。 局部变量：方法中

三、API

API基本：

一句话描述api：应用api就是（如何使用别人已经写好的东西）。

1、API：

(Application Programming Interface) 应用程序接口

2、简单理解：

API就是别人写好的东西，我们不需要自己编写，直接使用即可。

3、javaAPI：

指的是JDK中，提供的各种功能的java类。

这些功能将底层的实现封装起来，我们不需要知道，这些类是如何实现的，只需要知道如何应用即可。

将来还会学习其他知识，还会有其他的API。

4、API和API帮助文档：

API:目前是jdk提供的各种java类，将底层的实现封装起来。

API帮助文档：帮助开发人员更好的使用API和查询API的一个工具。

如何使用API帮助工具：

1. 打开API帮助文档(我的电脑在E盘，develop中，名为jdk…中文版)。
2. 点击左上方，索引，输入关键字，然后单击右键。
3. 查看类所在的包。
4. 先看构造方法。
5. 再看成员方法。

四、字符串

一、String

1、String概述：

java.lang.String类 代表字符串，java程序中，所有字符串文字（例如“abc”）都为此类的对象。

例：String name = "尼古拉丝·啊伟"（对象）

String的注意点：

1. 字符串的内容是不会发生改变的，他的对象在创建后不能被改变。
2. String是java定义好的一个类。定义在java.lang包中，所以使用的时候不需要导包。
3. java程序中所有字符串文字都被视为此类的对象。
4. 就像1.所强调的一样，字符串被创建后，便不可变。

2、创建String对象的两种方式:

直接赋值：

例：String name = “abcde”;

new

构造方法 说明

public String()                          创建空白字符串，不包含任何内容

public String(String original)    根据传入的字符串，创建字符串对象

public String(char[] chs)          根据字符串数组，创建字符串对象

public String(byte[] chs)          根据字节数组，创建字符串对象

例：

3、内存分配：

==号，到底比的是什么：

基本数据类

例：

int a=20;
int b=20;
System.out.println(a==b);//true

基本数据类型比的是数据值。

引用数据类

String s1=new String("abc");
String s2=new String("abc");
System.out.println(s1 == s2);//false

引用数据类型比的是地址值。

4、字符串比较：

boolean equals方法(要比较的字符串) 完全一样为true，否则为false。

boolean equalsIgnoreCase(要比较的字符串) 忽略大小写的比较。

以上就是例图喽，我暂时还没用到equalsIgnoreCase。

5、几个String方法的应用

String replace(旧值，新值)替换；

注意点，只有返回值才是替换之后的结果。

java charAt()方法

语法：public char charAt(int index);

index — 字符串的索引。

返回值：返回指定索引处的字符。

实例：1

public class Test{
    public static void main(String args[]){
        String str = "www.run.com";
        char result = str.charAt(3);
        System.out.println(result);// 为 .    
    }
}

public int length() : 返回字符串长度;

String str = "hello world!"
int len = str.length();//12
注意：""引的是String字符串，''单引号引的是char，一个字符。

长度计算：

数组长度：数组名.length;

字符串的长度：字符串对象.length();

String substring(int beginindex,int endindex) 截取

注意点：包头不包尾，包左不包右，只有返回值才是截取后的结果。

String substring(int beginindex) 截取到结尾。//index索引，指数。

二、StringBuilder

StringBuilder可以看成一个容器，创建之后里面的内容是可变的。作用—高效。

1、StringBuilder构造方法：

空参：public StringBuilder();

实参：public StringBuilder(String str);//根据字符串内容来创建对象。

2、StringBuilder常用方法：

1. append() 添加数据
2. reverse() 翻转内容
3. length() 返回长度
4. toString() 通过toString()可以把toString转化为String。

链式编程

—->在我们使用一个方法时，不需要其他变量继续接收，可以继续调用其他方法。

三、StringJoiner

StringJoiner根StringBuilder一样

同：都是一个容器，可以改变；
不同：StringJoiner在jdk8后才出现，很少有人用，但是更高效。

StringJoiner构造：

1、add

添加数据，并返回对象本身。

2、length()

返回长度（字符个数）

3、toString()

返回字符串并把StringJoiner转化成toString

四、字符串原理

扩展1：字符串储存原理

1、直接赋值会复用字符串常量池中的。

2、new出来的不会复用，而是直接开辟一个新空间。

扩展2：==号比较的到底是什么？

1、基本数据类型比较的就是数据值。

2、引用数据类型比较地址值。

扩展3：字符串拼接的底层原理

1、没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。

2、如果有变量参与，会创建新的字符串，浪费内存。

详解：
public class Test{
    public static void main(String[] args){
        String s1 = "111";//直接赋值，在串池中进行
        String s2 = s1+"222";//由于是拼接先在StringBuilder中存放
        String s3 = s2+"333";         
    }
}
其中：new StringBuilder()--拼接-->toString()
以上与String s="111"+"222"+"333",不同。

扩展4：StringBuilder提高效率原理图

1、所有要拼接的内存都会往StringBuilder中放，不会创建很多无用的空间。

扩展5：StringBuilder原码分析

· 默认创建一个长度为16的数组

·添加的长度小于16，直接存

·添加的长度大于16，先扩容在存(容量为*2+2为34)

·如果扩容之后还不够，才以实际长度为准。

扩展6：字符串转变成字符数组

//"ABC" ['A' , 'B' , 'C' ]；

· char[] arr = str.toCharArray();

衍生问题：

· 如何把字符数组当成字符串输出：sout（arr）；

五、集合

集合：

介绍：集合与数组同又不同。（与数组的区别）

同：都是用来存储数据的。

不同：数组长度固定，可以储存基本、引用两种数据类型。

集合长度可变，只能储存引用这一种数据类型。

应用：

ArrayList list = new ArrayList<>();

ArrayList 变量名 = new ArrayList<(在jdk8以后就可以不填)>();

boolean add() 添加

list.add("aaa");

list.add("bbb");

list.add("bbb");

boolean remove() 删除

list.remove("aaa");//其实这样就可以了，下面那个是检查。

boolean result1 = list.remove("aaa");

E set(int index,E e) 修改

boolean result2 = list.remove("bbb");

E get(int index) 查询

String str = list.get(0);

int size() 获取长度

int number = list.size();

ArrayList:

是java中的一个动态数组实现，属于java集合框架中的一部分，它提供了一个可以动态增长的数组，可以灵活地添加，删除和访问。ArrayList是list接口的实现类。

集合有很多，但ArrayList是常用的那一个。

并且在应用ArrayList时，要进行导包。

import java.util.ArrayList。

六、进阶学习

1、static

static—>表示静态，是java中的一个修饰符，可以修饰成员变量和成员方法。

被static修饰的成员变量叫静态变量

特点：

特点：

被该类的所有对象共有

不属于对象，属于类

随着类的加载而加载，优先于对象的存在。

解释：

调用方法：

类名调用(推荐)

用static修饰的方法，直接用类名调用，如：Student.teacherName();

因为，static随着类名调用时，直接被调用。它是优先于对象出现的。

对象名调用

被static修饰的成员方法叫静态方法

特点：

多用于测试类和工具类中

javabean类中很少会用

调用方法：

类名调用(推荐)

对象名调用

工具类：

javabean类 用来描述一件事物的类。

测试类 用来检查其他类是否正确，带有main方法的类，是程序的主入口。

工具类 不是用来描述一类事物的，而是用来做一些事情的类。

详解：

1、见名知意：
2、私有构造：
3、方法定义为静态：
public class Arrutil{
    private Arrutil(){}
        public static int getMax(...){...}
        public static int getMin(...){...}    
}

扩展1

public 和 private是两种修饰符，用于限定成员的可见性。

public:成员被声明为public，意味着该成员对任何一个类都是可见的，不管是不是一个包中。

private:是私有的，你懂…..

详细：

扩展2

静态方法只能访问静态方法和静态变量

非静态方法可以访问（非）静态变量和（非）静态方法，四种

静态方法中没有this关键字；

到此我知道，以后忘得话，我会看不懂—–>补充代码块

public class student{
    String name;
    int age;
    static String teacherName;
    //定义非静态(动态)方法
    public void show(---其实这里为String this--只是省略了----){
        sout(name,age,teacherName);
        //其实，sout中也有省略，如this.name,this.age。
public staic void show(){
    //这样写其实就会报错，sout(name,age,teacherName)
    因为静态，不能访问name，age这些静态。
    sout(this.name,this.age,teacherName);
}
    }
}

2、继承

1、什么是继承，继承的好处

是什么：是面向对象中的三大特征之一(封装，继承，多态)，使类之间产生子父关系；

好处：提高复用性

2、继承的特点

特点–格式->public class 子类 extends 父类{ }

子类可以得到父类的属性和行为，子类可使用；

子类可以在父类的基础上添加新的东西；

3、子类到底能继承父类中的哪些内容？（内存图/内存分析工具）

内容：

继承只能单继承，不能多继承，但是可以多层继承；

继承中所有类都直接或间接继承Object类。

子类只能访问父类中的非私有的成员变量。

4、继承中：成员变量的访问特点

先在局部位置找，本类成员中找，最后往父类位置找，逐级往上。

5、继承中：成员方法的访问特点

与4相似。

6、继承中：构造方法的特点

父类中的构造方法不会被子类继承。

子类中的所有构造方法默认先访问父类的构造方法，在执行自己

为什么：

子类在初始化时可能会先使用父类的数据，如果父类未初始化，子类无法使用父类的数据。

子类在调用之前一定会先调用父类的构造方法，完成父类空间的初始化。

怎么调用：

在空参构造中，一般默认都先是：super()，不写也存在。且必许在第一行

在有参构造中，要调用父类，必许要手动写super进行调用。

图解：

@Override

注意：这次说一下构造方法重写加上“ @Override注释可以校验重写是否正确，同时可读性好。 ”。

重写的方法尽量要跟父类保持一致。
public class fu{
    System.out.println("father");
}
public class son extends fu{
    @Override//@Override注释更多是校验是否正确。
    System.out.println("son");
    //覆盖的大都是虚方法中的，
    //方法重写的本质就是覆盖。
}

虚方法：

虚方法存在虚方法表中，虚方法每被继承一次，就会在继承链中添加一次。被static、final、private三者修饰符修饰，不能进入虚方法表中

详解：

7、this、super使用总结

当成员变量被私有化后：

用super才是最好的选择。

最最最重要的一点是super是用在继承中的，他找的是他的爹。而不会是外面的类。

3、包、final、权限修饰

包

作用：

包就是文件夹，用来管理不同的java类

命名规则：

公司域名的反写+包的作用，需要全部英文小写，见名知意

什么是全类名：

包名+类名

什么时候需要导包：

使用同一个包的类时，不需要导包。

使用java.lang包中的类时，不需要导包。

如果同时使用两个包中的同类名，需要用全类名。

final

final修饰方法

最终方法不能被重写。        

final修饰类：

最终类，不能被继承。

final修饰变量：

是变量，不能被修改。

基本数据类型：变量的值不能被修改。

引用数据类型：地址值不能修改，内部的属性可以被修改。

权限修饰符

用来控制一个成员能够被访问的范围。

private(仅一个类中)< (默认不填)(同一个包中)< protected (不同包中子父类能用)< public(不同包间)

代码块的分类

4、抽象类

//抽象类的定义方法
public abstract 返回值类型 方法名(参数列表);
//切记切结，不是：public abstract 返回值类型 方法名(参数列表){}
//抽象类的定义格式
public abstract class 类名{}

方法和意义：

在父类和子类关系中，定义的方法功能不一样，可能是要重写的。这样不同的人分工时，能更好的编写代码。

5、接口

定义和使用：

接口用关键字interface来定义；

接口不能实例化

接口的子类(实现类)

要么重写接口中的所用类的抽象方法，要么是抽象类

接口和类之间是实例关系，implement关键字来表示。

public class 类名 implements 接口名{}

注意：

//接口和类之间的实现关系
public class 类名 implements 接口名1，接口名2{}
//实现类还可以在继承一个类的同时实现多个接口。
public class 类名 extends 父类 implements 接口名1，接口名2{}

接口中成员的特点

成员变量

                只能是常量

                常量的默认修饰符为： public static final

构造方法

                没有

成员方法

                只能是抽象方法

                默认修饰符：public abstract

JDK8以后接口中新增的方法

允许在接口中定义默认方法，需要用关键字default修饰。

接口中默认方法的格式：default–>

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

范例：public default void show(){};

接口中默认方法的注意事项：

不被强调重写，但如果将会去掉default关键字，public 可以省略，但是default不能省略。如果实现多个接口，多个接口中存在默认方法名字相同，则子类必须进行重写。

接口中静态的定义方法格式：

格式：public static 返回值类型 方法名(参数列表){}

范例： public static void main(){}

注意事项：

静态方法只能通过接口来定义，不能通过实现名或者对象名调用

public可以省略，static不能省略。

适配器设计模式：

其实就是设计类一个中间类，将接口中的所用类的抽象方法进行了空实现。

适配器：XXXAdapter—–>格式。

过程：对接口中的抽象方法进行空实现

让真正的实现类继承中间类，并重写需要的方法。

实现类：

在面向对象的编程中，实现类是指一个类(或对象)实现了一个接口或则继承了一个抽象类，并提供类该接口或抽象类中的所有方法具体实现，实现类负责实现接口或者抽象类中声明的方法。

接口的多态：

接口 j = new 实现类对象。

6、多态

优势？

方法中，父类作为参数，可接受所有所有子类对象。

弊端？

不能使用子类的特殊情况。

引用数据

//引用数据转换
Person p = new Student();
//强制类型转换
Student s = (Student)p;

强制类型转化

可以真正的转换为子类类型，从而调用子类独特的功能。

转换类型与真实对象类型不会一致。

转化类型时可以应用instanceof关键字进行判断。

其中 a instanceof Cat c;中先看a是否为Cat类型，如果是强制转换，然后命名为a; 

7、内部类

总：成员内部类，静态内部类，局部内部类这三个了解，匿名内部类要掌握。

成员内部类

静态内部类

静态内部类：

静态内部类是一类特殊的成员内部类。

直接创建静态内部类对象的方式？

Outer.Inner oi = new Outer.Inner();

如何调用静态内部类：

局部内部类

匿名内部类

new 类名或者接口名(){       //继承\实现
  重写方法                 //方法重写
};                        //创建对象

如要更加详细解释，请点击——->这个是快速简介匿名内部类的，非常好

匿名内部类的具体应用：

1、什么是匿名内部类

隐藏类名字的内部类，可以写在成员位置，也可以写在局部位置。

2、匿名内部类的格式

new 类名或方法名(){ 重写方法； };

3、格式的细节

包含了继承或现实，方法重写，创建对象。

整体就是一个类的子类对象或者接口的实现类。

4、使用场景

当方法的参数时接口或者类时

以接口为例，可以传递这个接口的实例对象。

如果实现类只要使用一次，就可以用内匿名部类简化代码。

若有不足，指出必改

作者：ん贤