JAVA回顾1

标识符的使用规则
答：
定义合法的标识符需要满足的规则：
a.由数字、字母、下划线（_）、美元符号（$）组成
b.不能以数字开头   abc    1abc(不合法)
c.不能使用关键字   class(不合法)
d。遵循驼峰命名法
e.不可以包含空格     abc def(不合法)
f。不能包含除了$之外的特殊字符    abc&（不合法）

在Java中，严格区分大小写
abc Abc 
数据类型
答：分类：基本数据类型和引用数据类型

基本数据类型：数值型（byte\short\int\long）、字符型(char)、浮点型(float\double)、布尔型(boolean)
引用数据类型：类、数组、接口
数据的类型转换
答：1>自动类型转换
相兼容的数据类型，将取值范围较小的数值或者变量赋值给取值范围较大的类型对应的变量

注意：a.整型的默认类型为int，浮点型的默认类型为double
b.byte.short,char类型的变量在进行运算时，首先会将类型提升为int型，然后参与运算

c.整型核浮点型进行计算时，会将整型提升为浮点型，然后参与运算

2>强制类型转换
相兼容的数据类型，将取值范围较大的数值或者变量赋值给取值范围较小的类型对应的变量
运算符：++ --  | & 
答：1.算术运算符
+ - * / %(求余)，++（自增） --（自减）
2.赋值运算符
= += -= *= /= %=(复合赋值运算符)-----给变量进行赋值
3.关系运算符
< > <= >= ==(恒等于) != (不等于)
用于两个变量之间比较大小，如果成立则结果为true，如果不成立则结果为false
4.逻辑运算符
用于链接布尔型的表达式
int x = 4;
数学中：3 < x < 5---->true
代码中：
与（&，&&（短路与））、或（|、||）、异或（^）、非（！）
5.位运算符【0为false，1为true】
&  | ^ ~(取反) <<(左移)   >>(右移) >>>(无符号右移)
注意：除了无符号右移之外，其余的运算均包含符号
if，switch  while for
答：1.顺序语句
按照顺序从上往下依次执行的语句，中间没有任何的判断和跳转

2.分支语句
根据不同的条件来产生不同的分支
if语句、switch语句

3.循环语句
重复执行某句代码
for语句、while语句、do-while语句



二、分支语句
1.什么是分支？
判断所给定的条件是否满足，根据不同的结果执行对应的不同的语句

2.if语句
使用布尔表达式或者布尔值作为条件来进行分支控制

1>简单if语句（单分支）
语法：if(条件表达式) {

//执行语句
}
这里的条件表达式一般为关系运算符
使用方式：首先判断条件表达式是否成立，如果成立则执行语句，反之，不执行

2>if-else语句（双分支）
语法：if(条件表达式) {
//执行语句1
}
else {
//执行语句2
}
使用方式：首先判断条件表达式是否成立，如果成立则执行语句1，如果不成立，则执行语句2



3>多重if-else语句
语法：if(条件表达式1) {
//执行语句1
} else if(条件表达式2) {
//执行语句2
}else if(条件表达式3) {
//执行语句3
}
。。。。。。

else {
//执行语句
}
使用方式：根据不同表达式的成立与否执行对应的语句。只执行其中的一个分支，如果其中的一个分支条件满足，则停止继续向下执行

4>扩展：嵌套if语句
语法：if(条件表达式1) {
//执行语句1
if(条件表达式2) {
//执行语句2
}
}
从语法的角度来说，嵌套的层数没有限制，但是从代码的可读性来说，建议嵌套的层数不要多于3层



注意：使用if语句时容易出现的错误：
1.if(条件表达式);
{

}
2.忘记必要的括号

2.switch语句
语法：
switch(表达式或者变量) {

case 常量值1：
{
//执行语句1
}
break;
case 常量值2：
{
//执行语句2
}
break;
case 常量值3：
{
//执行语句3
}
break;
.。。。。。
default:
{
//执行语句
}

}
根据表达式或者变量的值进行匹配，如果case中有能匹配到的，则执行对应的语句，如果所有的case语句都不满足，则执行default中的语句

注意：a.表达式或者变量的取值类型：byte\short\int\char\String\枚举，（不能使用long和boolean）
b.若表达式的值和case分支后的常量值匹配的话，则执行该case分支
c。break表示跳出switch-case语句
d.当所有的case分支都不匹配的情况下，则执行default语句



扩展：Scanner类的使用



if语句和switch语句的区别：
a.如果对具体的数值进行判断，并且数值不多的情况下，而且符合byte\short\int\char这四种类型，推荐使用Switch完成，执行效率相对高一点
b。如果对区间进行判断，结果为布尔值的情况下，推荐使用if，if的使用范围更广



三、循环语句
1.什么是循环？
在满足条件的情况下，反复执行某一段代码，这段被反复执行的代码就被称为循环体
当反复执行这段循环体时，需要在合适的时候将循环条件改为假，从而结束循环，否则循环会一直执行下去，形成死循环
2.while循环
语法：while(条件表达式) {
//循环体
}
当条件表达式成立时，才会执行循环体
循环体的执行次数取决于条件表达式

3.do-while语句
语法：do{
//循环体

}while(条件表达式);



4.for循环语句

语法：for(表达式1；表达式2；表达式3){

//循环体
}

表达式1：初始化表达式
表达式2：循环条件表达式
表达式3：循环后的操作表达式

执行顺序：表达式1（int x = 0）--->表达式2----》循环体---》表达式3-----》表达式2----》循环体---》表达式3。。。。。。
其中，表达式1只执行一次

扩展：嵌套for循环


四、特殊流程控制语句
1.break

应用范围：分支结构和循环结构
作用：跳出对应的结构



2.continue
应用范围：循环结构
作用：表示结束当前循环，继续下一次循环，并不会结束整个循环



3.return
return并不是专门用于跳出循环的，作用是结束一个方法
return直接结束一个方法，不管这个return处于多少层循环之中



三者之间的区别：
a。break和continue的应用范围不同
b.当程序中出现break和continue时，在他们的后面不能出现语句，因为执行不到
c。continue是结束当前循环，break是结束整个循环
d.return直接结束整个方法
方法：返回值，参数，静态和非静态，全局变量和局部变量
答：1.什么是方法？
对于功能相同的代码段，为了简化代码，会把功能相同的代码抽取出来，方便多次使用，Java中，我们使用【方法】，也被称为函数



2.函数的声明
语法：
访问权限修饰符 其他修饰符 返回值类型 函数名称（参数列表）{

//函数体
}

public static void main(String[] args) {

}
a.访问权限修饰符：目前全部要求使用public，和main函数保持一致
b.其他的修饰符：只有static（要么写，要不不写）
c.返回值类型：函数运行后所得结果对应的数据类型，void表示空
d。函数名称：见名知意
e.参数列表：如果方法中有未知数参与运算，未知数对应的类型和变量名

3.函数的调用


4.static的使用
1》全局变量和局部变量
全局变量：在类中定义的变量，和main函数是并列的，在整个类中有效
局部变量：在方法内定义，并且只能在方法内部使用，当方法执行完成之后，这个变量就消失了
注意：局部变量在使用的时候一定要先进行初始化
局部变量局部有效，只在定义这个变量的方法内有效  {}



注意：在使用全局变量和局部变量的时候，尽量避免命名相同



2》静态方法：被static修饰的方法称为静态方法，不加static则为非静态方法



5.方法中参数
分类：形式参数（形参）和实际参数（实参）
调用方法的时候，用实参给形参赋值，这个过程称为传参
传参时需要注意：实参的数量和类型要与形参的数量以及类型相匹配


6.方法压栈
栈：是内存中的一块空间（开口向上的容器）
入栈和出栈：先进后出，后进先出
局部变量在栈中开辟空间

注意：a。JVM首先执行main函数，main函数入栈
b.当执行到swap方法的时候，swap函数入栈
c.当所有的操作执行完成之后，方法需要出栈，swap先出栈，mian函数后出栈，所占有的空间全部被释放





7.方法的返回值
一个方法执行完成之后所得到的结果
void表示没有返回值

使用return得到最终的结果，用于结束整个方法



8.提取一个方法注意事项
a。明确实现的功能，当调用函数的时候，是否需要返回结果----返回值类型
b,明确是否有未知项参与运算-------参数列表




8.函数的递归
递归：在一个方法中调用它自身，称为方法的递归
方法递归中包含了隐式的循环，他会重复执行某段代码，但是在这里不需要循环
冒泡、，选择。二分法
答：1.排序

1>冒泡排序
思路：比较相邻两个下标对应的元素值，如果符合条件就交换位置（最值出现在最右边）


2>选择排序
思路：固定一个下标，然后使用这个下标对应的值依次和他后面的值进行比较





2.查找
1>顺序查找
思路：遍历数组，依次把每一位元素和要比较的数值进行比较

2>二分法查找
思路：前提是一个数组是有序，通过折半来缩小查找范围，提高效率
一、不定长参数
1.语法：数据类型... 变量名称

使用注意事项：a.不定长参数就相当于是一个数组
b.不定长参数只能出现在参数列表的最后面
c.一个函数的参数列表中只能出现一次不定长参数
d.对于不定长参数的使用，调用函数的时候，可以传入不定长的数值，或者可以直接传入数组
面向对象
答：面向过程和面向对象的区别：
面向过程：一种看待问题的思维方式，在解决问题的时候，着眼于问题是怎样一步一步解决的，然后亲力亲为的去解决每个步骤中遇到的问题
面向对象：一种看待问题的思维方式，着眼于找到一个具有特殊功能的具体的个体，然后委托这个个体去帮忙做某件事情，这个个体就被称为对象

区别总结：
a.都是一种看待问题的思维方式
b.面向过程着眼于所有的问题亲力亲为解决
c.面向对象着眼于找到一个具有特殊功能的对象，然后委托这个对象去帮忙做某件事情

封装，继承，多态
答：1.什么是封装？
一个类中某些属性，如果不希望外界直接访问，我们可以将这个属性作为私有的，可以给外界暴露出来一个访问的方法
使用封装解决私有化的问题
2.什么是继承？
如果两个或者两个以上的类具有相同的属性和方法，我们可以抽取一个类出来，在抽取出来的类中声明各个类中公共的部分
一种事物的多种体现形式
Java中的体现形式：
1>父类的引用指向子类的对象
2>接口的引用指向实现类的对象
构造方法
答：构造方法也叫作构造器，是当实例化一个对象（创建一个对象）的时候，第一个被调用的方法
语法：访问权限修饰符 类名（） {



}
普通方法：
访问权限修饰符 其他的修饰符 返回值类型 函数名（参数列表） {

}

注意：a.构造方法是在实例化对象的过程中自动调用的
b.系统会默认为我们提供一个无参的构造方法



构造方法和普通方法的区别
a.构造方法没有返回值
b。构造方法的方法名必须和类名保持一致



使用构造方法的过程中容易出现的问题;。
a.如果没有写有参的构造方法，系统会为我们提供一个默认的无参的构造方法
b。如果手动写了有参的构造方法之后，系统将不再提供无参的构造方法，如果需要使用，则需要手动加上（要求：一般情况下，将无参的构造方法加上，哪怕方法里面什么都不写）
面向对象语言的三大特性;封装、继承、多态
get/set方法
答：对于private修饰的成员变量，如果要在外界使用，则使用get和set方法进行取值和赋值


语法
get------获取值
访问权限修饰符 返回值类型（成员变量的类型）getXxx() {   例如：public int getAge() {}
}

set-----赋值
访问权限修饰符 void setXxx(成员变量类型 变量名称) {   例如：public void setAge(int a){}
}
方法的重载
答：在同一个类中，如果满足以下的条件时，我们就称为这几个方法之间彼此重载
a.方法名相同
b.参数不同（数量不同，类型不同）
c.跟返回值类型没有关系



方法重写
答：1.重写规则
在具有继承关系的两个类中，子类中的方法如果满足了以下条件，就说子类重写了父类的方法
a.方法名相同
b.参数相同
c.子类方法的返回值类型必须和父类方法的返回值类型相同，或者是父类方法返回值类型的子类型
d.子类方法的访问权限必须大于等于父类方法的访问权限

对象的向上向下转型
答：1.对象的向上转型
由子类类型转换为父类类型
由实现类类型转换为接口类型

对象向上转型之后就不能再访问子类中特有的方法和属性
对象向上转型之后就不能再访问实现类中特有的方法，

2.对象的向下转型
由父类类型转换为子类类型:强制类型转换
抽象类、抽象方法
答：1、定义
当多个类中出现相同功能，但是功能主体是不同的，这是可以进行向上抽取的，只抽取功能的定义部分，使用抽象类实现

抽象类的存在就是为了被继承



2.使用
abstract

3.抽象类的特点
a.使用关键字abstract修饰的类
b.抽象类不可以使用new关键字进行创建对象
c.抽象类中既可以写抽象方法，也可以写普通方法
d.如果子类只实现了抽象类中的部分抽象方法，那么这个时候子类仍然是一个抽象类

4.抽象方法的特点：
a.抽象方法必须存在于抽象类中
b.使用abstract修饰的方法
c.只有声明，没有实现

5.抽象类和一般类的区别
a.抽象类是在一般类的基础上，使用abstract修饰的类
b.抽象类中既可以有抽象方法，也可以有普通方法，普通类中只能有普通方法
c.抽象类不能用于实例化对象

接口
答;1.概念
初期理解：可以认为接口是一种特殊的抽象类，当抽象类中的方法全部是抽象方法的时候，我们就可以使用接口来表示

接口是抽象方法的集合，

2.使用
interface

语法：访问权限修饰符 interface 接口名称 
{
}

3.接口的特点
a.接口不能实例化对象
b.接口中不能写成员变量
接口中成员变量的修饰符是固定的，public  static final,在接口中出现的变量统统认为是常量
c.接口中默认所有的方法都是抽象方法
接口中方法的修饰符也是固定的，public abstract,接口中默认所有的方法都是抽象方法



4.接口的实现和类之间的关系
一个类如果要实现另外一个类中的方法的话，使用继承实现
一个类如果要实现一个接口中的方法的话，则需要实现这个接口

语法：
访问权限修饰符 class 子类类名 implements 接口名 {

}
其中，把实现了这个接口的类称为接口的实现类

注意：
a.子类必须实现接口中的全部的抽象方法，子类才可以实例化，否则，子类仍然是一个抽象类
b.一个类是可以实现多个接口，需要把实现的接口中的方法全部实现了
c.实现接口和类的继承之间没有关系，一个类在实现接口的同时也可以继承
d.接口之间是可以进行继承的，并且是多继承

总结
接口其实是对外暴露的规则
接口可以实现程序功能的扩展
接口可以用来多实现
接口之间是可以继承的，并且是多继承的关系
一个类在继承的同时可以实现接口
内部类
答：一个类中包含着另外一个类，里面的类被称为内部类，外面的称为外部类

1.成员内部类
和成员变量或者成员方法平级的内部类
语法：
访问权限修饰符  class 外部类类名{

//成员变量
//成员方法
访问权限修饰符 class 内部类类名 {

//内部类的类体
}
}

特点；
a.实例化对象的语法
Out out = new Out();
Out.In in = out.new In();
b。成员内部类四种访问权限修饰符都可以使用（一般类只能使用public和default）
c.成员内部类编译生成的class文件的格式：外部类类名$内部类类名，例如：Out$In.class



2.局部内部类
是和局部变量平级，存在于方法中的内部类
语法：
访问权限修饰符  class 外部类类名{

//成员变量
//成员方法
访问权限修饰符 返回值类型 方法名（参数列表） {



访问权限修饰符 class 内部类类名 {

//内部类的类体
}
}
}

特点：
a.局部内部类具有和局部变量相同的作用域
b.和局部变量类似，不能使用访问权限修饰符进行修饰
c.编译生成的class文件的格式：外部类类名$编号内部类类名 ，例如：Out$1In.class,Out$2In.class,
d。局部内部类如果要访问和他平级的局部变量，这个局部变量必须是一个常量
e.如果需要往外部类的方法中传入参数，外部类的方法形参必须使用final修饰

3.静态内部类
使用static修饰的成员内部类被称为静态内部类
语法：
访问权限修饰符  class 外部类类名{

//成员变量
//成员方法
访问权限修饰符 static  class 内部类类名 {

//内部类的类体
}
}

特点：
a.实例化内部类对象的格式：Out.In in = new Out.In();
b.静态内部类类似于静态成员变量，可以使用访问权限修饰符进行访问
c.静态内部类编译生成的class文件的格式：外部类类名$内部类类名，例如：Out$In.class
d.在静态内部类中只能访问外部类中的静态成员变量
e.在静态内部类中也可以写静态成员变量

4.私有内部类
被private修饰的成员内部类

语法：
访问权限修饰符  class 外部类类名{

//成员变量
//成员方法
private class 内部类类名 {

//内部类的类体
}
}



5.匿名内部类（重要）
没有名字的内部类
正因为没有名字，所以匿名内部类只能使用一次，通常用来简化代码，匿名内部类使用的前提条件：必须继承一个父类或者实现一个接口

特点：
a.匿名内部类没有名字
b.匿名内部类其实是指定类的子类或者指定接口的实现类
c.编译生成class文件的格式：测试类类名$编号，例如：InnerClassDemo05$1.class
访问权限修饰符
答：1.访问权限修饰符：public\private\protected\default
2.default:如果没有添加访问权限修饰符的话，其实就是default权限（注意：default一定不能写出来）
3.修饰类：类的访问权限修饰符只有两个：public和default

访问权限修饰符        同包 不同包
public    可以 可以
default     可以 不可以

说明：
public修饰的类在不同包下可以访问，但是需要注意：
a.进行导包（需要使用类的全限定名，例如：包名.包名.类名；import com.b.Student;）
b.如果在不同包中有相同名字的类，在使用的时候一定要注意使用类的全限定名

4.修饰属性:四个访问权限修饰符都能用
权限大小：public>protected>default>private


访问权限修饰符   本类 同包不同类 子类（不同包） 不同包
private 可以 不可以 不可以 不可以
default 可以 可以 不可以 不可以
protected 可以 可以 可以 不可以
public 可以 可以 可以 可以
this，super
答：this是对当前对象的引用
super是对父类对象的引用

1》super.属性：访问父类中的成员变量
2》super.方法：访问的是父类中的方法
3》super():访问的是父类的构造方法
注意：a.super()必须出现在子类构造方法的第一行语句
b.super()具体调用的是父类中的哪个构造方法，取决于所传的参数
单例设计模式
答：单例是一种设计模式，
什么是设计模式？
前人总结的用来解决特定问题的方案
Java中有23中设计模式，常用的有单例设计模式，工厂设计模式

什么是单例设计模式？

在程序运行过程中，确保某一个类只有一个实例（对象），不管在哪个模块获取这个类的对象，获取到的都是同一个对象

实现方式：
a.懒汉式（饱汉式）

b.饿汉式

区别：a.懒汉式在一定程度上节约内存，但是数据是不安全的（线程不安全）
b.饿汉式，不节约内存，但是数据比较安全
代码块
答：什么是代码块？
在类中独立存在的语句块，可以有多个，位置随意{}
什么是静态代码块？
被static修饰，直接出现在类中的语句块
语法：static {
//执行语句

}

用法：a.静态代码块用于为类的属性进行初始化
b.静态代码块是属于类的，随着类的加载而运行，每个静态代码块只会执行一次，静态代码块的执行优先于main函数

扩展：
4>普通代码块：在方法或者语句中出现的{}
普通代码块和一般语句的执行顺序由他们在代码中出现的顺序决定

5>构造代码块：直接在类中定义，且没有加static关键字的代码块
String、字符串操作
答：字符串是一种特殊的对象，一旦被初始化就不能被改变了

字符串常量存储于常量池中

常用类、对象包装类
答：1.对象包装类
int ----->Integer
byte-----Byte
short----Short
long------Long
boolean---Boolean
float-----Float
double----Double
char------Character

2.数据的装箱和拆箱
装箱：将基本数据类型转化为对应的对象包装类
拆箱：将对象包装类转化为对应的基本数据类型

3.String类和基本数据类型之间的转换

a.对象包装类的常见作用：用于基本数据类型和字符串类型之间的转换

4.Date类
用来表示日期的

5.SimpleDateFormat

6.Calendar

7.Random
获取随机数



8.Math
是一个工具类

Math类的构造器被私有化了，所以Math类中的方法全部是静态方法，可以直接通过类名进行调用，而且还提供了两个静态属性，PI和E,他俩的值其实就是π和e
枚举
答：JDK1.5之后引入的一个新的特性，存在于java.lang

表示取值范围限定的变量（四季，星期，月份）

枚举类和普通类的区别：
a.枚举类的父类java.lang.Enum，而不是Object
b。使用enum关键字（enumeration）
c.枚举类的构造器只能使用private访问权限修饰符
d.枚举类的的所有实例必须在枚举类中显式列出，系统会自动给这些实例添加修饰符public static final
e。所有的枚举类都提供了一个values方法，可以用来遍历枚举中所有的枚举值

语法
访问权限修饰符 enum 枚举名称 {
//枚举值
可能取得值1，可能取得值2，可能取得值3，....,可能取得值n;
}

注意：枚举值的命名需要全部大写，不同单词之间使用下划线分隔
泛型
答：1.概念
泛型指的是泛指的类型。主要用于子类和父类，接口和实现类之间的数据传递



JDK1.5之后新增的特性，主要用于解决安全问题，是一个安全机制



好处：
a.可以提高代码的复用性
b.避免了强制类型转换的麻烦
c.提高了代码的安全性
d.可以把运行时的异常提前到编译时


泛型：通过<>来定义要操作的引用数据类型

什么时候使用泛型？
通常使用在集合框架中，当遇到<>的时候，一般需要定义泛型

2.泛型的应用场景
a.泛型应用在类中

访问权限修饰符 class 类名<类型1，类型2。。。> 
{
}

b.泛型应用在接口中
interface 接口名称<类型1，类型2。。。> {

}

c。泛型应用在方法中
访问权限修饰符 <类型1，类型2.。。。> 返回值类型  方法名（参数列表） {


}

d.应用在集合中



e.通配符-------- ？
可以匹配任意类型
1><? super 类名>：可以是指定类或者指定类的父类

2><? extends 类名>:可以是指定类或者执行类的子类

集合
答：1.概念
数组：用来存储相兼容数据类型的定长的容器（基本数据类型和引用数据类型）
集合：存储引用数据类型的变长的容器（引用数据类型）
IO流
答：1.概念
File类只能创建或者修改文件或者文件夹的层级结构，如果要访问文件中的内容的话，就需要用到IO流（Input Output，输入输出流）



操作磁盘上的文件内容，实现数据的输入输出操作，磁盘上的文件和内存之间进行交互需要有一个媒介或者管道，这个媒介或者管道就称为IO流
反射
答：1.概念
反射机制指的是程序在运行的过程中，对于任意一个类，都能够知道这个类对应的所有的属性和方法；对于任意一个对象，都能够调用其中的任意的方法和属性，在Java中，把这种动态获取信息以及动态调用对象的方法的功能称为Java语言的反射机制
一个类编译之后会生成对应的class字节码文件，可以通过这个字节码文件动态的去获取所有的类，对类中的属性和方法进行访问
多线程
答：多线程：在一个进程中，多个线程同时进行
应用：一个浏览器可以同时下载多张图片
一个服务器可以同时响应多个用户请求

集合和IO流结合的大题
数组，字符串，集合，反射。多线程。流 ，集合和流