JAVA基础详细解释

旧城等待， 2021-09-03 03:28 624阅读 0赞

***\*java四类八种数据类型\****

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ULVijbZ6-1607223051009)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsB8B.tmp.jpg)\]

***\*三目运算符\****

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

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

其中"(a<b)?a:b"是一个"条件表达式",它是这样执行的:如果a<b为真,则表达式取a值,否则取b值.

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6YvUoEuo-1607223051011)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsB9B.tmp.jpg)\]

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

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

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

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

***\*Day10 面向对象\****

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

***\*public、 protected、\**** ***\*default\*\*\*\*\*\*\*\*和 private\****

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xXngDxk9-1607223051013)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsB9C.tmp.jpg)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vH952NpT-1607223051015)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsB9D.tmp.jpg)\]

***\*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 。

***\*成员内部类的面试题：\****

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wH0kohDG-1607223051017)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsB9E.tmp.jpg)\]

***\*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\}; //简易声明和赋值在同一行（用的较多）

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3idDePm0-1607223051019)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBAF.tmp.jpg)\]

二维数组

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();

输出如下

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u9j3LIgj-1607223051021)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBB0.tmp.jpg)\]

***\*//二维数组的相加\****

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 +" ");

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QoUkdGpZ-1607223051022)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBB1.tmp.jpg)\]

***\*this关键字\****

代表当前对象的引用；

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

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

***\*构造方法\****

构造方法不能用对象调用

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

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

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

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

没有具体的返回值return。

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fiOjnACb-1607223051024)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBC1.tmp.jpg)\]

采用SetXxx的形式更多一些；

***\*创建一个对象的步骤\****

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fSQIYdN9-1607223051027)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBC2.tmp.jpg)\]

***\*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关键字区别：\****

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nO21aXxC-1607223051029)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBC3.tmp.jpg)\]

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

***\*super 调用父类的成员，\****

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z0PJo2wm-1607223051030)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBD4.tmp.jpg)\]

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

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

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fxzVCEY2-1607223051031)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBD5.tmp.jpg)\]

/\*

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

\*/

***\*重写\****

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

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KWWfJOZr-1607223051031)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBD6.tmp.jpg)\]

***\*方法的重载\****

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

***\*重载的分类\****

***\*1.参数个数不同\****

***\*2.参数类型不同\****

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

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

***\*final关键字\****

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

***\*修饰类：类不能被继承；\****

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

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

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6H9enTyX-1607223051032)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBE7.tmp.jpg)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3xTB2Q67-1607223051033)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBE8.tmp.jpg)\]

***\*Day09面向对象\****

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

***\*多态的前提：\****

***\*1.要有继续关系，\****

***\*2.要有方法的重写，\****

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jOyGfody-1607223051034)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBE9.tmp.jpg)\]

***\*Father f\**** = new Son();

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

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

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

***\*多态的好处\****

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

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

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

***\*抽象类\****

***\*特点\****

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

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

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

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

***\*抽象类的子类\****

要么是抽象的

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IMAWYylQ-1607223051035)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsBF9.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9kyJnM8I-1607223051035)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC0A.tmp.jpg)\]

***\*抽象类的成员方法特点：\****

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

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

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

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

***\*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 会把后面的同名也选中，比较方便

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dLGdbLS8-1607223051036)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC0B.tmp.jpg)\]

查找具体方法：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):比较字符串的内容是否相同,区分大小写

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zZirTXXa-1607223051037)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC0C.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MnCunSNH-1607223051038)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC0D.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yXz6kTdn-1607223051038)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC1D.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KxaEnRNv-1607223051039)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC1E.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjgP0X3v-1607223051040)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC1F.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iezSsoGR-1607223051041)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC30.tmp.jpg)\]

***\*" "与null的区别：\****

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

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

***\** A:String类的获取功能\***\*

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EvvnjpyF-1607223051041)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC31.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LsqHz7gI-1607223051042)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC32.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0TsXavdP-1607223051042)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC33.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-izssfTiD-1607223051043)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC44.tmp.jpg)\]

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

引。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HbUiYZZj-1607223051044)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC45.tmp.jpg)\]

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

的索引。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9NHeo43d-1607223051044)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC46.tmp.jpg)\]

\* lastIndexOf

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hzmHW3KF-1607223051045)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC47.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oJVcY7fh-1607223051046)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC48.tmp.jpg)\]

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VkdE3mGq-1607223051046)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC58.tmp.jpg)\]

***\*迷惑题\****

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Di3tKKPk-1607223051047)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC59.tmp.jpg)\]

***\*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类的其他功能)

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ysprd14-1607223051048)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC5A.tmp.jpg)\]

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F8OdBnDh-1607223051048)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC5B.tmp.jpg)\]

***\*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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RANh4dWv-1607223051082)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC6C.tmp.jpg)\]

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()方法去清理垃圾（相当于呼喊保洁阿姨清理垃圾）

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D94JOSHu-1607223051082)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC6D.tmp.jpg)\]

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

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sBJidtqZ-1607223051083)(file:///C:\\Users\\adminXu\\AppData\\Local\\Temp\\ksohtml\\wpsC6E.tmp.jpg)\]

***\*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));

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]: 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
[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