java入门基础一 1-14 之四类八种数据类型

- 日理万妓 2021-09-07 06:04 259阅读 0赞

java四类八种数据类型

四类：整数、浮点、字符、布尔

八种 ： byte、short、int、long，float、double，char，boolean

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70][]

三目运算符

公式 表达式1 ? 表达式2 : 表达式3; 真的取前面的，假的取其后面的；

例如： true时取0 ，假的取 currentPage。 true时取15，假的取 pageSize

其中"(a

![20210121164526295.jpeg][]

[Java中，&&与&，||与|的区别][Java]

在[Java][Java 1]的逻辑运算符中，有这么四类：&&（短路与），&，|，||（短路或）。

&&和&都是表示与，区别是&&只要第一个条件不满足，后面条件就不再判断。而&要对所有的条件都进行判断。

|| 和 | 都是表示“或”，区别是||只要满足第一个条件，后面的条件就不再判断，而 | 要对所有的条件进行判断。

Day10 面向对象

[Java中访问权限修饰符protected, default][Java_protected_ default]

public、 protected、 default和 private

![20210121164526300.jpeg][]

![20210121164526298.jpeg][]

A 、修饰符：

权限修饰符：private 、默认的（default）、protected、public

状态修饰符：static、final

抽象修饰符：abstract

B、类：

权限修饰符：默认的（default）、public

状态修饰符： final

抽象修饰符：abstract

C、成员变量（属性）：

权限修饰符：private 、默认的（default）、protected、public 用的最多 private

状态修饰符：static、final

D、构造方法：

权限修饰符：private 、默认的（default）、protected、public 用的最多 public

E、成员方法：

权限修饰符：private 、默认的（default）、protected、public

状态修饰符：static、final

抽象修饰符：abstract

F、其他组合方式：

成员变量： public static fianl

成员方法： public static， public abstract， public final 。

成员内部类的面试题：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 1][]

for循环

break，continue，return 的区别

for (int i = 1; i

if(i % 3 ==4 )\{

//break; //跳出循环 （只针对循环内使用）

//continue; //终止本次循环继续下一次循环

//return; //跳出方法（在方法中使用）

//System.out.println("1111");

a: for (int i = 1; i < 10; i++) \{ // a: 控制跳转语句标号

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

b: for(int j = 1; j < 10;j++)\{

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

break a; //跳出a的for循环（）

方法的重载

1.方法名相同，方法的参数列表不同，与返回值的类型无关。

重载的分类

1.参数个数不同

2.参数类型不同

3.顺序不同（一般不用）

数组

//动态初始化方式

int\[\] arr = new int\[5\];

System.out.println(arr\[0\]); //系统给出默认初始化值，int默认值是 0

整数类型 ： byte， short ， int ， long ，默认初始化值都是 0。

浮点类型： float， double 默认初始化值都是 0.0.

布尔类型： boolean 默认值是 flase

字符类型：char 默认初始化值是 ' \\u0000 ' 。

数组声明

一维数组

//静态初始化方式

int\[\] arrs = new int\[\] \{11,22,33\};

//不允许动静结合 例如： int\[\] arrs = new int\[3\] \{11,22,33\};

int\[\] arr1 ;

arr1 = new int\[\] \{11,22,33\}; //非简易声明和赋值可以不再同一行

int\[\] arr2 = \{00,11,22,33\}; //简易声明和赋值在同一行（用的较多）

![20210121164526394.jpeg][]

二维数组

int\[\]\[\] aa = new int\[3\]\[2\]; //动态二维数组创建

int\[\] arra2\[\] = \{ \{11,1\},\{22,2\},\{33,3\}\}; //静态二维数组创建

//二维数组的遍历

for (int i = 0; i < arra2.length; i++) \{

System.out.print(arra2\[i\] +" 一位 ------------ ");

System.out.println();

//从二维数组中查找一维数组

for (int j = 0; j < arra2\[i\].length; j++) \{ //遍历一维数组

System.out.print(arra2\[i\]\[j\] +" 二位 ");

System.out.println();

输出如下

![20210121164526445.jpeg][]

//二维数组的相加

int sum = 0;

for (int i = 0; i < arra2.length; i++) \{ //从二维数组中查找一维数组

for (int j = 0; j < arra2\[i\].length; j++) \{ //遍历一维数组

sum = sum + arra2\[i\]\[j\];

System.out.print(sum +" ");

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 2][]

this关键字

代表当前对象的引用；

应用场景：用来区分全局成员变量（属性）和局部变量重名

this必须有对象的时候才有值；即在创建对象的时候才有值；（this是随着对象的创建而存在）

构造方法

构造方法不能用对象调用

在一创建对象的时候，系统就帮我们调用了构造方法

作用：给对象的数据（属性）进行初始化

特点：方法名与类名相同（大小也要有一致）

没有返回值类型，连viod都没有；

没有具体的返回值return。

构造方法也是有return语句的，格式是（ return ; ）

给成员变量赋值的两种方式的区别

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 3][]

采用SetXxx的形式更多一些；

创建一个对象的步骤

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 4][]

static静态关键字

在静态方法中没有this关键字；（静态比对象先存在）

静态方法只能访问静态的成员变量和静态方法；（静态只能访问静态）

原因：非静态的方法或者成员变量只能通过创建对象调用，（有可能还没有创建对象）

而静态方法或者静态成员变量可以通过类名调用；

非静态方法可以访问静态（类名.）或者非静态（对象名.）的方法和成员变量；

当一个类中所有的方法都是静态方法的时候就要私有它的构造方法，

目的（不让其他类创建这个类的对象）

main方法

public static void main(String\[\] args)\{ \}

public: 被jvm调用，所以需要足够大的权限

static：被jvm调用不需要创建对象，直接类名调用即可；

void： 被jvm调用不需要任何返回值；

main： 只有这样写才能被jvm识别，main不是关键字

Math.random()伪随机数

//Math.random()会生成大于等于0.0 并且小于 1.0的伪随机数 生成1到100的随机数

for (int i = 0; i < 10; i++) \{

System.out.println((int)(100\*Math.random())+1);

D[ay08][Java_protected_ default]面向对象

//构造代码块（初始化块） 而且优先于构造方法（函数）执行

// 在类中方法外出现；多个构造方法中相同的代码存放在一起；每次调用构造都执行，并且在构造方法前执行；

//作用： 构造代码块每次创建一次对象就会执行一次；先走构造代码块，再走构造方法；

//静态代码块 优先于主方法执行的，

// 在类中方法外出现，加了static修饰； 静态代码块是随着类的加载而加载，而且只执行一次，

//作用：用来给类进行初始化，一般用来加载驱动；

继承

优点:

提高了代码的复合性，

提高了代码的维护性，

让类于类之间产生了关系，是多态的前提

缺点： 类的耦合性增强了，

开发的原则是：高内聚（就是自己完成某件事的能力）、低耦合（类于类之间的关系）。

继承特点：只支持单继承，支持多层继承。

子类只能继承父类中所有非私有的成员。

子类不能继承父类的构造方法（原因：构造方法名和类名是同名，），但是可以通过super关键字区访问父类的构造方法，

什么时候使用继承：

继承是体现一种关系：is a 。

如果有两个类A 、B，中有他们复合A是B的一种，或者B是A的一种，就可以使用继承。

成员变量的关系：子父类出现同名的变量时，子类区调用父类的成员时，同名的时候就不会调用该成员，原因是子类中有该成员，会 就近原则取值。（实际开发时是不会出现这个问题的，）

this和super关键字区别：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 3][]

this： 即可以调用本类的成员，也可以调用父类的成员（在本类中没有的情况下）；

super 调用父类的成员，

![20210121164526378.jpeg][]

super() 语句，如果不写，系统会默认加上，用来访问父类中的空参构造方法。

每个构造方法的第一条语句默认都是 super(); 子类的父类 访问最大object父类

原因：子类会继承父类的数据，可能还是使用父类的数据。所以子类初始化之前，一定要先完成父类数据的初始化。

静态代码块、构造代码块和构造方法执行的先后顺序

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 5][]

/\*

1.jvm 调用main方法，main进栈

2.遇到Zi z =new Zi(); 会先将Fu.class和Zi.class分别加载到内存，再创建对象，

当Fu.class加载进内存， 父类的静态代码块会随着Fu.class一起加载，

当Zi.class加载进内存，子类的静态代码块会随着Zi.class一起加载，

第一个输出 父类静态代码块fu 第二个输出 子类静态代码块zi

3.走子类的构造方法 super(); Java是分层执行的， 先初始化父类再初始化子类， 所以会先走父类的构造，

在执行父类的构造时发现父类有 父类构造代码块 fu，（构造代码块是优先于构造方法先执行 ）

第三个输出是 父类构造代码 ---块 ---fu， 第四个输出 父类构造方法fu，

4.父类初始化完成， 子类初始化，第五个输出 子类构造代码 ---块 ---zi ，

第六个输出 子类构造方法zi

\*/

重写

定义：子类重写父类的方法；子类中出现和父类中方法声明一模一样的方法，与返回值值类型有关，返回值是一致的；

父类中私有方法不能被重写；原因：父类中私有的方法子类根本就无法继承，

子类重写父类方法时 子类的访问权限要大于或等于父类（最好是相等）；

![20210121164526360.jpeg][]

方法的重载

定义：1.方法名相同，方法的参数列表不同，与返回值的类型无关。

重载的分类

1.参数个数不同

2.参数类型不同

3.顺序不同（一般不用）

子类对象调用父类方法的时候先找本身，再找父类（就近原则）；

final关键字

final修饰特点：一般与public static 共用

修饰类：类不能被继承；

修饰变量：变量就变成了常量，只能被赋值一次；

修饰方法：方法不能被重写。

基本数据类型： 是值不能被改变；

引用数据类型：是地址值不能被改变，对象中的属性可以改变。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 7][]

Day09面向对象

多态 ： 食物存在的分种状态；

多态的前提：

1.要有继续关系，

2.要有方法的重写，

3.要有父类引用指向子类对象

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 8][]

Father f = new Son();

成员变量： 编译看左边（父类），运行看左边（父类）。

静态方法： 编译看左边（父类），运行看左边（父类）。

成员方法（普通方法）： 编译看左边（父类），运行看右边（子类）。又叫（动态绑定）。

多态的好处

提高了代码的维护性（继承保证）；

提高了代码的扩展性（由多态保证）；

强制向下转型关键字：instanceof 判断前面的引用是否是后面的数据类型

抽象类

特点

抽象类或者方法必须用 abstract 关键字修饰

抽象类不一定有抽象方法，有抽象方法的一定是抽象类或者是接口；

抽象类不能实例化（即不能创建对象， 那怎么实现抽象类的实例化呢？

按照多态的方式，由具体的子类实例化，其实这也是多态的一种，抽象类多态。

抽象类的子类

要么是抽象的

![20210121164526386.jpeg][]

要么重写抽象类中的所有抽象方法。

![20210121164526334.jpeg][]

抽象类的成员方法特点：

抽象方法： 强制要求子类做的事情；

非抽象方法： 子类继承的事情，提高代码的复用性。

抽象类中可以定义构造方法，

抽象类中可以不定义抽象方法，意义：不让其他类创建本类的对象，交给子类完成。

abstract 不能和 stratic 关键字共存。

原因：类名.抽象方法的调用是没有意义，抽象方法没有方法体

abstract 不能和 final 关键字共存。

原因：被 abstract 修饰的方法会强制子类重写；被 final 修饰的方法是不让子类重写，所在他俩是矛盾的。

abstract 不能和 private 关键与共存。

原因：被 abstract 修饰的方法是为了子类看到并继承的； 被 private 修饰的不让子类访问，所以他俩是矛盾的。

接口 ： 关键字 interface

接口不能被实例化，调用抽象方法没有意义；

可以按照多态的方式实例化 接口 接口名 = new 接口实现类();

接口的子类：

可以是抽象类，意义不大。

可以是具体类，要重写接口中的所有抽象方法。（推荐使用）

在接口中可以定义成员变量 int num =10 ； 但只能是常量并且是静态的公共的 ， 没意义；

成员变量的默认修饰符： public static final （三个关键字没有顺序要求）， 建议手动添加上。

接口没有构造方法；

接口中的方法：只能是抽象方法；

默认是修饰符 public abstract；

类与类，类与接口，接口与接口的关系：单继承多实现。

类与类是继承关系，只能是单继承，可以多层继承。

类与接口是实现关系，多实现，通过 ， 隔开。

接口与接口是继承关系，可以单继承，也可以多继承。

接口和抽象类的区别：

1、成员区别

A 、抽象类

成员方法，可以是变量，可以是常量。

构造方法： 有

成员方法： 可以是抽象方法，可以是普通方法；

B、 接口：

成员方法，只能是常量。

构造方法： 没有

成员方法： 只能是抽象方法；

2、关系区别： 类与 类是继承关系，类与接口是实现关系，接口与接口是单继承或多继承。

3、设计理念区别：

A、抽象类是 is-a 的关系 抽象类中定义是该继承体系的共性功能。是一个 继承关系

B、接口是 like-a 的关系 接口中定义是该继承体系的扩展功能。 像一个 组合关系

Day11Eclipse开发工具和API

MyEclipse开发快捷键：

导包：Art + /;

查看源码 ： 选中类名 （ 按F3或者Ctrl+鼠标点击），

上下移动：Art + 上下箭头；

查找具体类：Ctrl + Ctrl + Shift + t ；

Art+Shift + R : 选中一个后点击 Art+Shift + R 会把后面的同名也选中，比较方便

![20210121164526459.jpeg][]

查找具体方法：Ctrl + O；

给建议：Ctrl+ 1 根据右边生成左边的数据类型，生成方法；

删除代码：选中后Ctrl + d；

抽取方法： Art + Shift + m；

修改名字（类、方法）Art+Shift+ r 。

自动生成有无参构造方法和set、get方法：Art + Shift + S；

代码快速复制： Ctrl + Art + / ；

tostring() 方法：toString是Object类的方法，所有类都从Object类继承。如果你定义的类没有覆盖toString方法，则对象在调用toString方法时用的是Object类toString方法，返回的是“类名@hashcode".

当有非[字符型数据][Link 1]要转换成字符串类型时，一个toString()方法即可将类型进行转换

如果StringBuffer想要输出的话，则必须用toString()方法先转换成[String类][String]型，才能输出

因为它是Object里面已经有了的方法，而所有类都是继承Object，所以“所有对象都有这个方法”。

它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法

总而言之，它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法

写这个方法的用途就是为了方便操作，所以在文件操作里面可用可不用

equals()方法和 == 的区别：

共同点：都可以做比较，返回值都是 boolean 类型；

区别：1、 == 是比较运算符，既可以比较基本数据类型，又可以比较引用数据类型，基本数据类型

是 比较的值， 引用数据类型是比较的地址值；

2、 equals方法只能比较引用数据类型，equals()方法在没重写之前比较的是地址值，底层依

赖的是 == 号，但是比较地址值是没有意义的，我们需要重写equals方法比较对象中的属

性值。

Day11常见对象：

String类：

字符串是常量（final修饰），一旦被赋值 就不能被改变。

A:常见构造方法

\* public String():空构造

\* public String(byte\[\] bytes):把字节数组转成字符串

\* public String(byte\[\] bytes,int index,int length):把字节数组的一部分转成字符串

\* public String(char\[\] value):把字符数组转成字符串

\* public String(char\[\] value,int index,int count):把字符数组的一部分转成字符串

\* public String(String original):把字符串常量值转成字符串

public static void main(String\[\] args) \{

String s1 = new String();

System.out.println(s1);

byte\[\] arr1 = \{97,98,99\};

String s2 = new String(arr1); //解码,将计算机读的懂的转换成我们读的懂

System.out.println(s2);

byte\[\] arr2 = \{97,98,99,100,101,102\};

String s3 = new String(arr2,2,3); //将arr2字节数组从2索引开始转换3个

System.out.println(s3); 输出cde 从第二开始计算3个，包括第二个

char\[\] arr3 = \{'a','b','c','d','e'\}; //将字符数组转换成字符串

String s4 = new String(arr3);

System.out.println(s4);

String s5 = new String(arr3,1,3); //将arr3字符数组,从1索引开始转换3个

System.out.println(s5);

String s6 = new String("heima");

System.out.println(s6);

\* A:String类的判断功能

\* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

![20210121164526637.jpeg][]

\* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

![20210121164526637.jpeg][]

\* boolean contains(String str):判断大字符串中是否包含小字符串

![20210121164526636.jpeg][]

\* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

![20210121164526639.jpeg][]

\* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾

![20210121164526637.jpeg][]

\* boolean isEmpty():判断字符串是否为空。

![20210121164526661.jpeg][]

" "与null的区别：

" "是字符串常量，同时也是一个String类的对象，既然是对象当然可以调用String类中的方法；

null 是空常量，不能调用任何的方法，否则会出现空指针异常，null常量可以给任意的引用数据类型赋值。

\* A:String类的获取功能

\* int length():获取字符串的长度。

![20210121164526717.jpeg][]

\* char charAt(int index):获取指定索引位置的字符

![20210121164526636.jpeg][]

\* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。

![20210121164526670.jpeg][]

\* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。

![20210121164526676.jpeg][]

\* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索

引。

![20210121164526500.jpeg][]

\* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处

的索引。

![20210121164526636.jpeg][]

\* lastIndexOf

![20210121164526498.jpeg][]

\* String substring(int start):从指定位置开始截取字符串,默认到末尾。

![20210121164526631.jpeg][]

\* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包含头,不包含尾,左闭右开

![20210121164526503.jpeg][]

迷惑题

![20210121164526681.jpeg][]

String类的转换功能：

\* byte\[\] getBytes():把字符串转换为字节数组。

String a ="abc";

byte\[\] arra = a.getBytes();

for (int i = 0; i < arra.length; i++) \{

System.out.print (arra\[i\]+" ");//输出97 98 99

\* char\[\] toCharArray():把字符串转换为字符数组。

String a ="heima";

char\[\] a1 = a.toCharArray();

for (int i = 0; i < a1.length; i++) \{

System.out.print (a1\[i\]+" "); //输出 h e i m a

\* static String valueOf(char\[\] chs):把字符数组转成字符串。

char\[\] arra = \{'a','b','c'\};

String a1 = String.valueOf(arra);

System.out.println(a1); //输出 abc

\* static String valueOf(int i):把int类型的数据转成字符串。

String ints = String.valueOf(100);

System.out.println(ints + 100); // 输出 100100

\* 注意：String类的valueOf方法可以把任意类型的数据转成字符串。

常见对象(String类的其他功能)

![20210121164526639.jpeg][]

String的去除字符串两端空格及案例演示 String trim()

String s = " hei ma ";

//String的去除字符串两端空格及案例演示 String trim()

String s2 = s.trim();

System.out.println(s2); //輸出 “hei ma”

//倒叙输出字符串

String arr = "abc"; //添加一个字符串

char\[\] a1 =arr.toCharArray(); //将字符型转换成数组；

String s = ""; //定义一个空字符串

for(int i=a1.length-1;i >=0;i-- )\{ //倒叙遍历数组

s= s + a1\[i\];

System.out.println(s); //输出 cba

统计大串中小串出现的次数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 9][]

Day12常见对象：

线程安全效率低，线程不安全效率高。

\* B:StringBuffer和String的区别

\* String是一个不可变的字符序列

\* StringBuffer是一个可变的字符序列

StringBuffer线程安全的，效率低

StringBuffer sb3 = new StringBuffer();

System.out.println(sb3); // 输出 空值

System.out.println(sb3.toString()); //输出 空值 说明StringBuffer重写了toString方法。

\* A:StringBuffer的添加功能

\* public StringBuffer append(String str):

\* 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

验证 StringBuffer sb = new StringBuffer(); // 只new 创建一个对象

StringBuffer sb2 = sb.append(true); //sb sb2 sb3 sb4 指向同一个内存地址

StringBuffer sb3 = sb.append("heima");

StringBuffer sb4 = sb.append(100);

System.out.println(sb); //输出trueheima100

System.out.println(sb2); //输出trueheima100

System.out.println(sb3); //输出trueheima100

System.out.println(sb4); //输出trueheima100

//StringBuffer是字符串缓冲区，当new的时候在堆内创建一个对象，

//底层是一个长度为16的字符数组，当调用添加的方法时，不会再重新创建对象，

//在不断向原缓冲区添加字符。

\* public StringBuffer insert(int offset,String str):

\* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

StringBuffer 的insert方法 功能： 添加

StringBuffer sb = new StringBuffer();

sb.insert(3,"heima");

//插入数据 3 代表位置 heima 代表插入的数据。 因为0、1、2、的位置是空值

//所以输出 字符串下标越界错误 输出 StringIndexOutOfBoundsException

System.out.println(sb);

StringBuffer sb = new StringBuffer("1234");

sb.insert(3,"heima");

System.out.println(sb);//输出 123heima4 在3的下标添加

StringBuffer 的deleteCharAt方法 功能：

StringBuffer sb = new StringBuffer("1234");

sb.deleteCharAt(5);

System.out.println(sb); //报 越界异常 StringIndexOutOfBoundsException

sb.deleteCharAt(3);

System.out.println(sb); // 输出123

StringBuffer 的delete方法 功能： 删除

StringBuffer sb = new StringBuffer("heima");

sb.delete(0, 2);

System.out.println(sb); //输出 ima 包含头，不包含尾

清空缓冲区

StringBuffer sb = new StringBuffer("heima");

sb.delete(0,sb.length()); //清空缓冲区

System.out.println(sb);

StringBuffer 的replace和reverse方法 功能： 替换和反转

StringBuffer sb = new StringBuffer("heima");

sb.replace(0, 3,"bai"); //包含头，不包含尾

System.out.println(sb); //输出 baima

sb.reverse(); //倒叙输出方法

System.out.println(sb); //输出amieh

StringBuilder线程不安全，效率高 ，其方法与StringBuffer一样

String 与 StringBuffer 和StringBuilder的区别：

String是一个不可变的字符序列；

StringBuffer 和StringBuilder是可变的字符序列

StringBuffer 和StringBuilder 的区别：

StringBuffer 是线程安全的，效率低；

StringBuilder 是线程不安全的，效率高；

Day13常见对象：

冒泡排序

int\[\] arr = \{50,80,30,10,100\}; //声明一个数组

for (int i = 0; i < arr.length - 1; i++) \{ //外循环是比较的循环次数

for (int j = 0; j < arr.length -1 -i ; j++) \{ //内层循环控制每一趟排序多少次

//减i是为了提高效率，减1是为了下标越界 内循环是把数组元素的作对比

if(arr\[j\]> arr\[j+1\])\{ //通过if判断前后数组元素的大小 把大值交换到前面

int tem = arr\[j\];

arr\[j\] = arr\[j+1\];

arr\[j+1\] = tem;

for (int i = 0; i < arr.length; i++) \{

System.out.print(arr\[i\]+ " ");

Arrays类的方法和概述：

sort() 排序方法：

int\[\] arr = \{11,33,55,22,44,66,10\};

System.out.println(Arrays.toString(arr)); //输出 \[11, 33, 55, 22, 44, 66, 10\]

Arrays.sort(arr); //排序方法

System.out.println(Arrays.toString(arr)); //输出 \[10, 11, 22, 33, 44, 55, 66\]

binarySearch() 方法 查找

int\[\] a = \{10,22,30,45,55,65,99\};

System.out.println(Arrays.binarySearch(a,99)); //输出6 按照下标位置输出

基本数据类型的包装类

\* C:基本类型和包装类的对应

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

Integer类

System.out.println(Integer.toBinaryString(60)); // 转换二进制 输出 111100

System.out.println(Integer.toOctalString(60)); // 转换八进制 输出 74

System.out.println(Integer.toHexString(60)); // 转换十六进制 输出 3c

System.out.println(Integer.MAX\_VALUE); //2的31次方-1 输出2147483647

System.out.println(Integer.MIN\_VALUE); //-2的31次方 输出-2147483648

Integer的面试题：

Integer a1 = new Integer(100);

Integer a2 = new Integer(100);

System.out.println(a1 == a2); //false

System.out.println(a1.equals(a2)); //true

//equals()方法

//比较此对象与指定对象。当且仅当参数不为 null， 并且是一个与该对象包含相同 int 值的 Integer 对象时，结果为 true

![20210121164526637.jpeg][]

Integer a3 = 128; //大于等于128就为false

Integer a4 = 128; //大于等于128就为false

System.out.println(a3 == a4); //false

System.out.println(a3.equals(a4)); //true

//因为-128 到127 是byte的取值范围，如果在这个范围内取值 ，自动装箱就不会创建对象；

//而是从常量池中取值，

//如果超过了byte取值范围就会再创建新对象。

Day14简单看了一遍：

在一个源文件中不能出现两个public 修饰的class类文件，可以有多个类，但不能用两个public修饰

system类

finalize()方法

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。

system.gc() 运行垃圾回收器会调用fianlize()方法去清理垃圾（相当于呼喊保洁阿姨清理垃圾）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 10][]

exit()方法 非0状态是异常退出，退出jvm

终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非零的状态码表示异常终止

![20210121164526640.jpeg][]

currentTimeMillis()方法 获取当前系统时间

当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）；

long start = System.currentTimeMillis(); //开始时间

for (int i = 0; i < 1000; i++) \{

System.out.println("\*");

long end = System.currentTimeMillis(); //结束时间

System.out.println(end - start);

arraycopy()方法 数组拷贝；

//从原数组中赋值一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

int\[\] src = \{11,22,33,44,55\};

int\[\] dest =new int\[8\];

for (int i = 0; i < dest.length; i++) \{

System.out.print(dest\[i\]+" "); //输出 0 0 0 0 0 0 0 0

System.arraycopy(src, 0, dest, 0, src.length);

//原数组 ，原数组起始位置，新数组，新数组起始位置，原数组长度。

for (int i = 0; i < dest.length; i++) \{

System.out.print(dest\[i\]+" "); //输出 11 22 33 44 55 0 0 0

Date 类 的使用方法：

Date d = new Date();// 不传入参数 代表 系统当前时间 使用 无参构造

System.out.println(d); //输出系统当前时间Tue Jul 25 22:50:30 CST 2017

Date d1 = new Date(0); // 传入任何参数输出一样 使用 有参构造 通过毫秒值创建时间对象

System.out.println(d1);

//输出 Thu Jan 01 08:00:00 CST 1970 系统默认规定的时间 ， 08:00:00是北京东八区

setTime()方法设置毫秒值

Date d = new Date();

d.setTime(1000); //设置毫秒值 改变时间对象

System.out.println(d); //输出： Thu Jan 01 08:00:01 CST 1970 输出 起始时间

SimpleDateFormat 类的是用和讲述

format() 方法：

Date d = new Date(); //获取时间

SimpleDateFormat sd = new SimpleDateFormat(

"yyyy年MM月dd日 HH时：mm分：ss秒"); //创建日期格式化对象

System.out.println(sd.format(d)); //将日期格式转换为字符串

parse()方法

//将字符串转换成日期格式.

String str = "2010年10月10日 10:10:10"; //上下格式一定要完全相同，空格都不能相差。

SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

Date d = sd.parse(str);

System.out.println(d); 垃圾

Calendar 类

add()方法、 set()方法

Calendar c = Calendar.getInstance();

c.add(Calendar.MONTH, 1); //可以添加年、月、日， c.add(年月日,添加数);

c.set(Calendar.MONTH, 1); //可以设置年 、月、日 c.set(年月日, 设置数)

System.out.println(c.get(Calendar.MONTH));

# 代码如下： #

java四类八种数据类型
         四类：整数、浮点、字符、布尔
         八种 ： byte、short、int、long，float、double，char，boolean
    
      三目运算符
    公式  表达式1 ?  表达式2  :  表达式3;  真的取前面的，假的取其后面的； 
    例如： true时取0 ，假的取 currentPage。  true时取15，假的取 pageSize
    其中"(a<b)?a:b"是一个"条件表达式",它是这样执行的:如果a<b为真,则表达式取a值,否则取b值.         
    
    
    
     Java中，&&与&，||与|的区别
    在Java的逻辑运算符中，有这么四类：&&（短路与），&，|，||（短路或）。
    &&和&都是表示与，区别是&&只要第一个条件不满足，后面条件就不再判断。而&要对所有的条件都进行判断。 
     || 和 | 都是表示“或”，区别是||只要满足第一个条件，后面的条件就不再判断，而 | 要对所有的条件进行判断。
    
    Day10 面向对象
    Java中访问权限修饰符protected, default
    public、 protected、 default和 private
    
    
    
    A 、修饰符：
        权限修饰符：private 、默认的（default）、protected、public
        状态修饰符：static、final
        抽象修饰符：abstract
    B、类：
        权限修饰符：默认的（default）、public
        状态修饰符： final
        抽象修饰符：abstract 
    C、成员变量（属性）：
             权限修饰符：private 、默认的（default）、protected、public     用的最多  private
        状态修饰符：static、final
    D、构造方法：
               权限修饰符：private 、默认的（default）、protected、public     用的最多  public     
    E、成员方法：    
             权限修饰符：private 、默认的（default）、protected、public
        状态修饰符：static、final
        抽象修饰符：abstract
    F、其他组合方式：
              成员变量： public static fianl 
              成员方法： public static，     public abstract，    public final  。
    成员内部类的面试题：
    
    
    
    for循环
     break，continue，return 的区别
    for (int i = 1; i <= 10; i++) {
    			if(i % 3 ==4 ){
    				 //break;  //跳出循环 （只针对循环内使用）
    				 //continue;  //终止本次循环继续下一次循环
    				 //return; //跳出方法（在方法中使用）
    			}
    			//System.out.println("1111");
    		 }
      a: for (int i = 1; i < 10; i++) {   // a:  控制跳转语句标号
    			System.out.println("i="+i);
    			b: for(int j = 1; j < 10;j++){
    					System.out.println("j="+j);
    					break  a; //跳出a的for循环（）
    			    }
    		}
    方法的重载
    1.方法名相同，方法的参数列表不同，与返回值的类型无关。
    重载的分类
    1.参数个数不同
    2.参数类型不同
    3.顺序不同（一般不用）
    
    数组
         //动态初始化方式
         int[] arr = new int[5];
         System.out.println(arr[0]); //系统给出默认初始化值，int默认值是 0
    整数类型 ： byte， short ， int ， long ，默认初始化值都是 0。
    浮点类型： float， double 默认初始化值都是 0.0.
    布尔类型： boolean 默认值是 flase
    字符类型：char  默认初始化值是  '  \u0000  ' 。
    数组声明 
     一维数组
      //静态初始化方式
    int[] arrs = new int[] {11,22,33};    
    //不允许动静结合 例如：  int[] arrs = new int[3] {11,22,33};   
    int[] arr1 ;
    arr1 = new int[] {11,22,33}; //非简易声明和赋值可以不再同一行
    
    int[] arr2 = {00,11,22,33}; //简易声明和赋值在同一行（用的较多）
    
      二维数组
    	     int[][] aa = new int[3][2];    //动态二维数组创建 
    int[] arra2[] = {
       {11,1},{22,2},{33,3}};    //静态二维数组创建
    //二维数组的遍历
    for (int i = 0; i < arra2.length; i++) {
        System.out.print(arra2[i] +"  一位  ------------ ");
        System.out.println();
        //从二维数组中查找一维数组
        for (int j = 0; j < arra2[i].length; j++) {   //遍历一维数组
            System.out.print(arra2[i][j] +" 二位 ");
        }
        System.out.println();
    }
    输出如下
    
    
    //二维数组的相加
    int sum = 0;
    		for (int i = 0; i < arra2.length; i++) {          //从二维数组中查找一维数组
    			for (int j = 0; j < arra2[i].length; j++) {  //遍历一维数组
    				sum = sum + arra2[i][j]; 
    			} 
    		} 
    		System.out.print(sum +" ");
    
    
    this关键字
    代表当前对象的引用；
    应用场景：用来区分全局成员变量（属性）和局部变量重名 
    this必须有对象的时候才有值；即在创建对象的时候才有值；（this是随着对象的创建而存在）
    构造方法
    构造方法不能用对象调用
    在一创建对象的时候，系统就帮我们调用了构造方法
    作用：给对象的数据（属性）进行初始化
    特点：方法名与类名相同（大小也要有一致）
    没有返回值类型，连viod都没有；
    没有具体的返回值return。
    构造方法也是有return语句的，格式是（ return ; ） 
    给成员变量赋值的两种方式的区别
    
    采用SetXxx的形式更多一些；
    
    创建一个对象的步骤
    
    
    static静态关键字
    
    在静态方法中没有this关键字；（静态比对象先存在）
    静态方法只能访问静态的成员变量和静态方法；（静态只能访问静态）
    原因：非静态的方法或者成员变量只能通过创建对象调用，（有可能还没有创建对象）
    而静态方法或者静态成员变量可以通过类名调用；
    非静态方法可以访问静态（类名.）或者非静态（对象名.）的方法和成员变量；
    当一个类中所有的方法都是静态方法的时候就要私有它的构造方法，
    目的（不让其他类创建这个类的对象）
    main方法
    public static void main(String[] args){     }
    public: 被jvm调用，所以需要足够大的权限
    static：被jvm调用不需要创建对象，直接类名调用即可；
    void： 被jvm调用不需要任何返回值；
    main： 只有这样写才能被jvm识别，main不是关键字
    
    Math.random()伪随机数
    //Math.random()会生成大于等于0.0 并且小于 1.0的伪随机数    生成1到100的随机数
    		for (int i = 0; i < 10; i++) {
    			System.out.println((int)(100*Math.random())+1);
    		}
    
    Day08面向对象
    //构造代码块（初始化块）  而且优先于构造方法（函数）执行 
      // 在类中方法外出现；多个构造方法中相同的代码存放在一起；每次调用构造都执行，并且在构造方法前执行；
    	  //作用： 构造代码块每次创建一次对象就会执行一次；先走构造代码块，再走构造方法；
                        //静态代码块   优先于主方法执行的，
    	  // 在类中方法外出现，加了static修饰； 静态代码块是随着类的加载而加载，而且只执行一次，
    	   //作用：用来给类进行初始化，一般用来加载驱动；
    继承
      优点:
     提高了代码的复合性，
     提高了代码的维护性，
    让类于类之间产生了关系，是多态的前提
      缺点：   类的耦合性增强了，
    开发的原则是：高内聚（就是自己完成某件事的能力）、低耦合（类于类之间的关系）。
    继承特点：只支持单继承，支持多层继承。
    子类只能继承父类中所有非私有的成员。
    子类不能继承父类的构造方法（原因：构造方法名和类名是同名，），但是可以通过super关键字区访问父类的构造方法，
    什么时候使用继承：
    继承是体现一种关系：is a 。
    如果有两个类A 、B，中有他们复合A是B的一种，或者B是A的一种，就可以使用继承。
    成员变量的关系：子父类出现同名的变量时，子类区调用父类的成员时，同名的时候就不会调用该成员，原因是子类中有该成员，会 就近原则取值。（实际开发时是不会出现这个问题的，）
    this和super关键字区别：
    
    this： 即可以调用本类的成员，也可以调用父类的成员（在本类中没有的情况下）；
    super  调用父类的成员，
    
    super() 语句，如果不写，系统会默认加上，用来访问父类中的空参构造方法。
    每个构造方法的第一条语句默认都是  super();     子类的父类 访问最大object父类
    原因：子类会继承父类的数据，可能还是使用父类的数据。所以子类初始化之前，一定要先完成父类数据的初始化。
    静态代码块、构造代码块和构造方法执行的先后顺序
    
    /* 
    1.jvm 调用main方法，main进栈
    2.遇到Zi z =new Zi(); 会先将Fu.class和Zi.class分别加载到内存，再创建对象，
          当Fu.class加载进内存，  父类的静态代码块会随着Fu.class一起加载，
          当Zi.class加载进内存，子类的静态代码块会随着Zi.class一起加载，
          第一个输出    父类静态代码块fu  第二个输出     子类静态代码块zi
    3.走子类的构造方法  super(); Java是分层执行的， 先初始化父类再初始化子类，  所以会先走父类的构造，
           在执行父类的构造时发现父类有 父类构造代码块 fu，（构造代码块是优先于构造方法先执行 ）
            第三个输出是   父类构造代码  ---块 ---fu， 第四个输出     父类构造方法fu，
    4.父类初始化完成， 子类初始化，第五个输出    子类构造代码  ---块 ---zi ，
         第六个输出     子类构造方法zi
    */
    
    重写
    定义：子类重写父类的方法；子类中出现和父类中方法声明一模一样的方法，与返回值值类型有关，返回值是一致的；
    父类中私有方法不能被重写；原因：父类中私有的方法子类根本就无法继承，
    子类重写父类方法时  子类的访问权限要大于或等于父类（最好是相等）；
    
    
    方法的重载
    定义：1.方法名相同，方法的参数列表不同，与返回值的类型无关。
    重载的分类
    1.参数个数不同
    2.参数类型不同
    3.顺序不同（一般不用）
    
    子类对象调用父类方法的时候先找本身，再找父类（就近原则）；
    
    final关键字
    final修饰特点：一般与public static 共用
        修饰类：类不能被继承；
        修饰变量：变量就变成了常量，只能被赋值一次；
        修饰方法：方法不能被重写。
    基本数据类型： 是值不能被改变；
    引用数据类型：是地址值不能被改变，对象中的属性可以改变。
    
    
    
    
    Day09面向对象
       多态 ： 食物存在的分种状态；
      多态的前提：
        1.要有继续关系，
        2.要有方法的重写，
        3.要有父类引用指向子类对象
    
    Father f = new Son();
    成员变量： 编译看左边（父类），运行看左边（父类）。
    静态方法： 编译看左边（父类），运行看左边（父类）。
    成员方法（普通方法）： 编译看左边（父类），运行看右边（子类）。又叫（动态绑定）。
    多态的好处 
    提高了代码的维护性（继承保证）；
    提高了代码的扩展性（由多态保证）；
    强制向下转型关键字：instanceof 判断前面的引用是否是后面的数据类型
    抽象类
      特点
         抽象类或者方法必须用 abstract 关键字修饰 
         抽象类不一定有抽象方法，有抽象方法的一定是抽象类或者是接口；
         抽象类不能实例化（即不能创建对象， 那怎么实现抽象类的实例化呢？
          按照多态的方式，由具体的子类实例化，其实这也是多态的一种，抽象类多态。
    抽象类的子类
           要么是抽象的
    
           要么重写抽象类中的所有抽象方法。
    
    
    抽象类的成员方法特点：
        抽象方法： 强制要求子类做的事情；
        非抽象方法： 子类继承的事情，提高代码的复用性。
    抽象类中可以定义构造方法，
    抽象类中可以不定义抽象方法，意义：不让其他类创建本类的对象，交给子类完成。
    abstract 不能和 stratic 关键字共存。
    原因：类名.抽象方法的调用是没有意义，抽象方法没有方法体
    abstract 不能和 final 关键字共存。
    原因：被 abstract 修饰的方法会强制子类重写；被 final 修饰的方法是不让子类重写，所在他俩是矛盾的。
    abstract 不能和 private 关键与共存。
    原因：被 abstract 修饰的方法是为了子类看到并继承的； 被 private 修饰的不让子类访问，所以他俩是矛盾的。
    接口 ： 关键字 interface
    接口不能被实例化，调用抽象方法没有意义；
    可以按照多态的方式实例化     接口 接口名 =  new 接口实现类();
    接口的子类：
        可以是抽象类，意义不大。
        可以是具体类，要重写接口中的所有抽象方法。（推荐使用）
    在接口中可以定义成员变量 int num =10 ； 但只能是常量并且是静态的公共的 ， 没意义；
    成员变量的默认修饰符： public static final  （三个关键字没有顺序要求）， 建议手动添加上。
    接口没有构造方法；
    接口中的方法：只能是抽象方法；
          默认是修饰符 public abstract；
    类与类，类与接口，接口与接口的关系：单继承多实现。
       类与类是继承关系，只能是单继承，可以多层继承。      
       类与接口是实现关系，多实现，通过 ， 隔开。
       接口与接口是继承关系，可以单继承，也可以多继承。
    接口和抽象类的区别：
       1、成员区别   
     A 、抽象类
          成员方法，可以是变量，可以是常量。
          构造方法： 有
         成员方法： 可以是抽象方法，可以是普通方法；
     B、 接口：
           成员方法，只能是常量。
           构造方法： 没有
           成员方法： 只能是抽象方法； 
        2、关系区别： 类与 类是继承关系，类与接口是实现关系，接口与接口是单继承或多继承。
        3、设计理念区别： 
            A、抽象类是 is-a 的关系 抽象类中定义是该继承体系的共性功能。是一个  继承关系
            B、接口是 like-a 的关系 接口中定义是该继承体系的扩展功能。    像一个  组合关系
     
    Day11Eclipse开发工具和API
    MyEclipse开发快捷键：
        导包：Art + /;
        查看源码 ： 选中类名 （ 按F3或者Ctrl+鼠标点击），
        上下移动：Art + 上下箭头；
        查找具体类：Ctrl + Ctrl + Shift + t ；
       Art+Shift + R : 选中一个后点击 Art+Shift + R 会把后面的同名也选中，比较方便
    
        查找具体方法：Ctrl + O；
        给建议：Ctrl+ 1 根据右边生成左边的数据类型，生成方法；
        删除代码：选中后Ctrl  + d；
        抽取方法： Art + Shift + m；
       修改名字（类、方法）Art+Shift+ r 。
       自动生成有无参构造方法和set、get方法：Art + Shift + S；
       代码快速复制： Ctrl + Art + /  ；
    tostring() 方法：toString是Object类的方法，所有类都从Object类继承。如果你定义的类没有覆盖toString方法，则对象在调用toString方法时用的是Object类toString方法，返回的是“类名@hashcode". 
       当有非字符型数据要转换成字符串类型时，一个toString()方法即可将类型进行转换  
        如果StringBuffer想要输出的话，则必须用toString()方法先转换成String类型，才能输出
    
    因为它是Object里面已经有了的方法，而所有类都是继承Object，所以“所有对象都有这个方法”。
    它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法
    总而言之，它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法
    写这个方法的用途就是为了方便操作，所以在文件操作里面可用可不用
    
    equals()方法和 == 的区别：
       共同点：都可以做比较，返回值都是 boolean 类型；
       区别：1、 == 是比较运算符，既可以比较基本数据类型，又可以比较引用数据类型，基本数据类型  
                        是 比较的值， 引用数据类型是比较的地址值；
                 2、 equals方法只能比较引用数据类型，equals()方法在没重写之前比较的是地址值，底层依              
                       赖的是 == 号，但是比较地址值是没有意义的，我们需要重写equals方法比较对象中的属
                       性值。
    Day11常见对象：
      String类：
          字符串是常量（final修饰），一旦被赋值  就不能被改变。
          A:常见构造方法
    	* public String():空构造
    	* public String(byte[] bytes):把字节数组转成字符串
    	* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
    	* public String(char[] value):把字符数组转成字符串
    	* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
    	* public String(String original):把字符串常量值转成字符串
    	public static void main(String[] args) {
    		String s1 = new String();
    		System.out.println(s1);
    
    		byte[] arr1 = {97,98,99};		
    		String s2 = new String(arr1);			//解码,将计算机读的懂的转换成我们读的懂
    		System.out.println(s2);
    		
    		byte[] arr2 = {97,98,99,100,101,102};
    		String s3 = new String(arr2,2,3);		//将arr2字节数组从2索引开始转换3个
    		System.out.println(s3);   输出cde    从第二开始计算3个，包括第二个
    		
    		char[] arr3 = {'a','b','c','d','e'};	//将字符数组转换成字符串
    		String s4 = new String(arr3);
    		System.out.println(s4);
    		
    		String s5 = new String(arr3,1,3);		//将arr3字符数组,从1索引开始转换3个
    		System.out.println(s5);
    		
    		String s6 = new String("heima");
    		System.out.println(s6);
    * A:String类的判断功能
    	* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
    
    	* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    
    	* boolean contains(String str):判断大字符串中是否包含小字符串
     
    
            * boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
    
    	* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
    
    	* boolean isEmpty():判断字符串是否为空。
    
    
    " "与null的区别：
       " "是字符串常量，同时也是一个String类的对象，既然是对象当然可以调用String类中的方法；
      null 是空常量，不能调用任何的方法，否则会出现空指针异常，null常量可以给任意的引用数据类型赋值。
    
    * A:String类的获取功能
    	* int length():获取字符串的长度。
    
    	* char charAt(int index):获取指定索引位置的字符
    
      * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
    
    	* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
     
    
    
    	* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索    
              引。
    
    	* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处
              的索引。
    
    	* lastIndexOf
    
    	* String substring(int start):从指定位置开始截取字符串,默认到末尾。
    
     * String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包含头,不包含尾,左闭右开
    
    迷惑题
    
    String类的转换功能： 
    	* byte[] getBytes():把字符串转换为字节数组。
                    String a ="abc";
    		 byte[] arra = a.getBytes();
    		 for (int i = 0; i < arra.length; i++) {
    			 System.out.print (arra[i]+" ");//输出97 98 99  
    		}
    	* char[] toCharArray():把字符串转换为字符数组。
                    String a ="heima";
    		char[] a1 = a.toCharArray();
    		for (int i = 0; i < a1.length; i++) {
    			System.out.print (a1[i]+" "); //输出  h e i m a 
    		}
    	* static String valueOf(char[] chs):把字符数组转成字符串。
    		char[] arra = {'a','b','c'};
    		String a1 = String.valueOf(arra);
    		System.out.println(a1); //输出   abc
    	* static String valueOf(int i):把int类型的数据转成字符串。
    		String ints = String.valueOf(100);
    		System.out.println(ints + 100); // 输出 100100
    	* 注意：String类的valueOf方法可以把任意类型的数据转成字符串。  
     常见对象(String类的其他功能) 
    
    String的去除字符串两端空格及案例演示 String trim()
      String s = "  hei  ma  "; 
     //String的去除字符串两端空格及案例演示 String trim()
     String s2 = s.trim();
     System.out.println(s2); //輸出   “hei  ma”
    
    //倒叙输出字符串
    	 String arr = "abc";  //添加一个字符串
    	 char[] a1 =arr.toCharArray();  //将字符型转换成数组；
    	 String s = "";	      //定义一个空字符串
    	 for(int i=a1.length-1;i >=0;i-- ){   //倒叙遍历数组
    		 s= s + a1[i];       
     	 }
    	 System.out.println(s);  //输出  cba 
    统计大串中小串出现的次数
    
    
    Day12常见对象：
    线程安全效率低，线程不安全效率高。
    * B:StringBuffer和String的区别
    	* String是一个不可变的字符序列
    	* StringBuffer是一个可变的字符序列 
    StringBuffer线程安全的，效率低
              StringBuffer sb3 = new StringBuffer();
    	  System.out.println(sb3); // 输出 空值 
               System.out.println(sb3.toString()); //输出 空值  说明StringBuffer重写了toString方法。
    
    * A:StringBuffer的添加功能
    	* public StringBuffer append(String str):
    		* 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
      验证       StringBuffer sb  = new StringBuffer(); // 只new 创建一个对象
    		StringBuffer sb2 = sb.append(true);   //sb sb2 sb3 sb4  指向同一个内存地址
    		StringBuffer sb3 = sb.append("heima");
    		StringBuffer sb4 = sb.append(100);  
    		System.out.println(sb);  //输出trueheima100
    		System.out.println(sb2); //输出trueheima100
    		System.out.println(sb3); //输出trueheima100
    		System.out.println(sb4); //输出trueheima100
    	//StringBuffer是字符串缓冲区，当new的时候在堆内创建一个对象，
           //底层是一个长度为16的字符数组，当调用添加的方法时，不会再重新创建对象，
           //在不断向原缓冲区添加字符。
    	* public StringBuffer insert(int offset,String str):
    		* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
    StringBuffer 的insert方法 功能：  添加
            StringBuffer sb = new StringBuffer();
    	sb.insert(3,"heima");  
    	//插入数据 3 代表位置   heima 代表插入的数据。  因为0、1、2、的位置是空值
    	//所以输出 字符串下标越界错误   输出  StringIndexOutOfBoundsException
    	System.out.println(sb); 
    	StringBuffer sb = new StringBuffer("1234");
    	sb.insert(3,"heima");    
    	System.out.println(sb);//输出   123heima4 在3的下标添加
    StringBuffer 的deleteCharAt方法 功能：
       StringBuffer sb = new StringBuffer("1234");
       sb.deleteCharAt(5); 
      System.out.println(sb);  //报 越界异常  StringIndexOutOfBoundsException
      sb.deleteCharAt(3);
      System.out.println(sb);  // 输出123
    StringBuffer 的delete方法 功能：    删除
    		StringBuffer sb = new StringBuffer("heima");    
    		sb.delete(0, 2);
    		System.out.println(sb); //输出 ima   包含头，不包含尾
          清空缓冲区
                   StringBuffer sb = new StringBuffer("heima");    
    		sb.delete(0,sb.length()); //清空缓冲区 
    		System.out.println(sb);  
    StringBuffer 的replace和reverse方法 功能：  替换和反转
    		StringBuffer sb = new StringBuffer("heima");
    		sb.replace(0, 3,"bai"); //包含头，不包含尾
    		System.out.println(sb); //输出  baima 
    		sb.reverse(); //倒叙输出方法
    		System.out.println(sb); //输出amieh 
    StringBuilder线程不安全，效率高   ，其方法与StringBuffer一样
              String   与 StringBuffer 和StringBuilder的区别：
    String是一个不可变的字符序列；
    StringBuffer 和StringBuilder是可变的字符序列
             StringBuffer 和StringBuilder 的区别：
                              StringBuffer  是线程安全的，效率低；
                               StringBuilder  是线程不安全的，效率高；
      
    Day13常见对象：
    冒泡排序
                    int[] arr = {50,80,30,10,100};  //声明一个数组
     		for (int i = 0; i < arr.length - 1; i++) {    //外循环是比较的循环次数
     			for (int j = 0; j < arr.length -1 -i ; j++) { //内层循环控制每一趟排序多少次
    
     				//减i是为了提高效率，减1是为了下标越界   内循环是把数组元素的作对比
    				 if(arr[j]> arr[j+1]){   //通过if判断前后数组元素的大小 把大值交换到前面
    					 int tem = arr[j];
    					 arr[j] = arr[j+1];
    					 arr[j+1] = tem;
    				 }
    			}
    		}
     		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i]+ " ");
    		}
    
    Arrays类的方法和概述：
           sort()  排序方法：
                    int[] arr = {11,33,55,22,44,66,10};
    		System.out.println(Arrays.toString(arr)); //输出 [11, 33, 55, 22, 44, 66, 10]
    		Arrays.sort(arr);  //排序方法
    		System.out.println(Arrays.toString(arr)); //输出 [10, 11, 22, 33, 44, 55, 66]
           binarySearch() 方法   查找
     		int[] a = {10,22,30,45,55,65,99};
    		System.out.println(Arrays.binarySearch(a,99)); //输出6  按照下标位置输出
    基本数据类型的包装类
           * C:基本类型和包装类的对应 
    		byte  	 Byte
    		short	 Short
    		int		 Integer
    		long		 Long
    		float		 Float
    		double	 Double
    		char		 Character
    		boolean	 Boolean
        Integer类
         System.out.println(Integer.toBinaryString(60)); // 转换二进制  输出 111100
         System.out.println(Integer.toOctalString(60)); // 转换八进制    输出 74 
         System.out.println(Integer.toHexString(60)); // 转换十六进制     输出 3c
    	    System.out.println(Integer.MAX_VALUE);  //2的31次方-1   输出2147483647
    	    System.out.println(Integer.MIN_VALUE);   //-2的31次方    输出-2147483648
     Integer的面试题：
                   Integer a1 = new Integer(100);
    		Integer a2 = new Integer(100);
    		System.out.println(a1 == a2);        //false
    		System.out.println(a1.equals(a2));   //true
    //equals()方法
    		//比较此对象与指定对象。当且仅当参数不为 null， 并且是一个与该对象包含相同 int 值的 Integer 对象时，结果为 true
    
    	Integer a3 = 128; //大于等于128就为false
    	Integer a4 = 128;  //大于等于128就为false
    	System.out.println(a3 == a4);        //false
    	System.out.println(a3.equals(a4));   //true 
    	//因为-128 到127 是byte的取值范围，如果在这个范围内取值 ，自动装箱就不会创建对象；
    	//而是从常量池中取值，
    	//如果超过了byte取值范围就会再创建新对象。
    
    Day14简单看了一遍：
    在一个源文件中不能出现两个public 修饰的class类文件，可以有多个类，但不能用两个public修饰
    system类
    finalize()方法
    当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。
    system.gc()  运行垃圾回收器会调用fianlize()方法去清理垃圾（相当于呼喊保洁阿姨清理垃圾）
    
    exit()方法  非0状态是异常退出，退出jvm
    终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非零的状态码表示异常终止
    
    currentTimeMillis()方法     获取当前系统时间
    当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）；
                    long start = System.currentTimeMillis(); //开始时间
    		for (int i = 0; i < 1000; i++) {
    			System.out.println("*");
    		}
    		long end  = System.currentTimeMillis();  //结束时间
    		System.out.println(end - start);
        
    arraycopy()方法  数组拷贝；
    		//从原数组中赋值一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
                    int[] src = {11,22,33,44,55};
    		int[] dest =new int[8];
     		for (int i = 0; i < dest.length; i++) {
    			System.out.print(dest[i]+" "); //输出  0 0 0 0 0 0 0 0 
    		}  
    		 System.arraycopy(src, 0, dest, 0, src.length); 
    		//原数组 ，原数组起始位置，新数组，新数组起始位置，原数组长度。
    		for (int i = 0; i < dest.length; i++) {
    			System.out.print(dest[i]+" ");   //输出    11 22 33 44 55 0 0 0
    		}
    
    Date 类 的使用方法：
    		Date d = new Date();// 不传入参数 代表 系统当前时间    使用 无参构造
    		System.out.println(d); //输出系统当前时间Tue Jul 25 22:50:30 CST 2017
    		Date d1 = new Date(0); // 传入任何参数输出一样  使用 有参构造 通过毫秒值创建时间对象
    		System.out.println(d1);
    		//输出  Thu Jan 01 08:00:00 CST 1970 系统默认规定的时间 ， 08:00:00是北京东八区
        setTime()方法设置毫秒值
    		Date d = new Date(); 
    		d.setTime(1000); //设置毫秒值  改变时间对象
    		System.out.println(d); //输出：  Thu Jan 01 08:00:01 CST 1970    输出 起始时间
    
    SimpleDateFormat 类的是用和讲述
            format() 方法：
            Date d = new Date();                        //获取时间
    	SimpleDateFormat sd = new SimpleDateFormat(
    			"yyyy年MM月dd日   HH时：mm分：ss秒");     //创建日期格式化对象
    	System.out.println(sd.format(d));           //将日期格式转换为字符串
            parse()方法
    	   //将字符串转换成日期格式.
    	  String str = "2010年10月10日  10:10:10";  //上下格式一定要完全相同，空格都不能相差。
     	  SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss");      
    	  Date d = sd.parse(str);
    	  System.out.println(d); 垃圾
    Calendar 类
             add()方法、  set()方法
    		Calendar c = Calendar.getInstance();
    		c.add(Calendar.MONTH, 1); //可以添加年、月、日， c.add(年月日,添加数); 
    		c.set(Calendar.MONTH, 1);  //可以设置年 、月、日 c.set(年月日, 设置数)
    		System.out.println(c.get(Calendar.MONTH));

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70]: /images/20210827/fa3dc491fb324e399a48e44343e45061.png
[20210121164526295.jpeg]: /images/20210827/5817cb02a015468082990ab7519e5b42.png
[Java]: http://blog.csdn.net/lishiyuzuji/article/details/8116516
[Java 1]: http://lib.csdn.net/base/javase
[Java_protected_ default]: http://blog.csdn.net/u013238950/article/details/50918474
[20210121164526300.jpeg]: /images/20210827/85cdb11c20754d71a1eae12572cf3454.png
[20210121164526298.jpeg]: /images/20210827/22ff546f660d4306a228728e4da6a2e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 1]: /images/20210827/70b99764856841ce9b4300eeab0d06b9.png
[20210121164526394.jpeg]: /images/20210827/28d1517956894a188f87ec6aae45b0cb.png
[20210121164526445.jpeg]: /images/20210827/d3916eefc52d40ca9d51ca5dba009f0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 2]: /images/20210827/20178ae29d254707aa6d7725f537d407.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 3]: /images/20210827/61f1ff87337d48e2b462c6b8eb1d3414.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 4]: /images/20210827/40006f043d634cd88deb298478336d53.png
[20210121164526378.jpeg]: /images/20210827/91ed8295b0e44ac59d0e23edf9ac6d6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 5]: /images/20210827/8bc2026fb00945c4b1194422f2f6dbf3.png
[20210121164526360.jpeg]: /images/20210827/f993f06939bf485bac7c1a0570cbc927.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 6]: /images/20210827/881bf9c614624c52a876845adf83af00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 7]: /images/20210827/d109d054d4134500b20f671ec702bc20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 8]: /images/20210827/839849a8a4f8494388b0bb1f68de524b.png
[20210121164526386.jpeg]: /images/20210827/4256d6cfc38d4838b2403b1d81c83485.png
[20210121164526334.jpeg]: /images/20210827/df777b696d0c4eb984b9408ab3df94bb.png
[20210121164526459.jpeg]: /images/20210827/909e0804e3c94ac0bd79bd85b47046cd.png
[Link 1]: https://www.baidu.com/s?wd=%E5%AD%97%E7%AC%A6%E5%9E%8B%E6%95%B0%E6%8D%AE&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YLmh7-nWRdn1mYnhfYnWfs0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EP1DkPj61PjDvn1fdPHmdPj0d
[String]: https://www.baidu.com/s?wd=String%E7%B1%BB&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YLmh7-nWRdn1mYnhfYnWfs0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EP1DkPj61PjDvn1fdPHmdPj0d
[20210121164526637.jpeg]: /images/20210827/68cc1ffd145341258da558444e8dd0a7.png
[20210121164526636.jpeg]: /images/20210827/59ce33ba4ddb4c2d8748584300a1a406.png
[20210121164526639.jpeg]: /images/20210827/772f005208c645aea29014a662fab30c.png
[20210121164526661.jpeg]: /images/20210827/b418c9faaa6242428702967dd004c567.png
[20210121164526717.jpeg]: /images/20210827/d9f6585c18a94c0d8b4de2607671950b.png
[20210121164526670.jpeg]: /images/20210827/259f35726e9a4f0989b68682b61a4bb8.png
[20210121164526676.jpeg]: /images/20210827/b31a63932a504234884059587f07b00a.png
[20210121164526500.jpeg]: /images/20210827/3fcdb4078605438f81b580edd43ac81b.png
[20210121164526498.jpeg]: /images/20210827/cb90ae14e4b94655ba4c148048ff27c7.png
[20210121164526631.jpeg]: /images/20210827/bc906423924843debdbc67d88ac69e24.png
[20210121164526503.jpeg]: /images/20210827/6b1d6978fa674daebaf621cd94a1107a.png
[20210121164526681.jpeg]: /images/20210827/40878d964f7e49ff81427e51a8bd6a69.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 9]: /images/20210827/cd5f57c48c7a472da5d97c810ad230c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTYxMjI2_size_16_color_FFFFFF_t_70 10]: /images/20210827/9f1cada0c0c14fcb94383bc94e1c86de.png
[20210121164526640.jpeg]: /images/20210827/358db76ffd2242df9877434726ae359c.png