======一、Java的基础知识=

Java的前身是oak(橡树)，与1995年正式改名并且退出Java1.0版本。
Java之父是詹姆斯高斯林
三大开发平台的发布是在发布jdk1.5的时候。
Java的三大开发平台：j2se(标准级开发平台),j2ee(企业级开发平台),j2me(移动端的开发平台)、
在jdk1.7的时候，由于经营不善sun公司被Oracle公司收购
jdk1.8(8.0)和jdk(11.0)是Oracle公司承诺会长时间维护更新的稳定性版本

Java的特点：简单易学，跨平台，面向对象===(新时代衍生的最新特点是：众多互联网大厂的推崇，跨平台，拥有雄厚的编程资源)

Java的运行机制：Java的源代码-编译器(编译为以.class结尾的文件【字节码文件】)-解释器(将字节码文件翻译为机器码)

特点：Java独特的运行机制保证了Java语言及有效率又能够跨平台

JDK的名词解释
JVM:Java虚拟机，屏蔽了不用操作系统底层之间的差异，为Java语言的跨平台提供了支持
JRE:Java的运行环境，包括了解释器+JVM+类库

JDK:开发者工具包，包括了JRE+编译器+相关的工具+类库

编码规范：
1、一行代码写完用 ; 结束
2、一行只写一句代码
3、养成良好的缩进习惯
标识符的规范：
1、标识符没有长度的限制
2、对于大小写敏感
3、不能使用关键字，保留字(const,goto),三个特殊值(true,false,null)

=二、变量的概念：======

变量：变量是计算机内部的一块存储空间，是存储数据的基本单位

组成：变量类型+变量名+数值

数据的基本类型
八种基本数据类型：整数(byte,short,int,long),小数(double,float),布尔(boolean),字符(char)
byte(1B,-128~127,) short(2B,-32768~32767) int(4B, -2147483648~2147483647) long(8B,-2^63~263-1)
double(称为双精度浮点数,8B-84位，-1.79E+308~1.79E+308)
float(单精度浮点数, 4B-32位, -3.4E+38~3.4E+38)
boolean(true/false) 就俩个值真和假
char(2B 16位 0~65535)可以存储字符也可以存储一个中文

6.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

short s1 = 1; s1 = s1 + 1; 有错，(s1+1 运算结果为int类型，需要强制类型转换)short s1 = 1; s1 += 1; 没有错的

2、引用类型/对象类型
String(字符串)数组均为引用类型
“A”—>字符串 ‘A’---->字符 //单引双引的区别

3、数据类型的转换
语法：目标数据类型变量名 = (源数据类型)变量名
场景：当目标数据类型范围>源数据类型范围时正常转化
当目标数据类型范围<源数据类型范围时强制转换

发生强制转换的三种结果：1.源数据类型存的数据<目标数据类型范围    不会丢失精度2.源数据类型存的数据>目标数据类型范围    丢失精度3.小数类型转换为整数时，小数部分丢失只保留整数部分

=======================================================================================
4、运算符
算数运算符：+, -, , /, %,
赋值运算符：=, +=, -=, =, %=, /=
自增运算符：++, --, (a++,++a a++执行完运算后+1, ++a先执行+1在运算 ) (a–,--a a–执行完运算后-1, --a先执行-1在运算)
int a= 5 int b =(a++)+(++a)+(–a) 求a，b的值
分为三步计算：① int b = 5+(++a)+(–a) 这时候a执行a++ 此时a=6 int b = 6+(++a)+(–a)
② int b = 6+ 7 +(–a) 这时候a执行++a 此时a=7 int b = 6+ 7 +(–a)
③ int b = 6+ 7 +6 此时–a=7-1
b= 19 a=6
关系运算符：==, >, <, >=, <=, !=
逻辑运算符：&, |, ！[与，或，非]
条件运算符：[三元运算符] 布尔？值a:值b [先判断布尔值，为真时执行值a，为假时执行值b]

2、&&(短路与)与&(非短路与),||(短路或)与|(非短路或)
a&&b，a&b, a||b, a|b
&&： a&&b 都为真时整体为真，a为false时，不判断b
& a&b 都为真时整体为真 a为false时，判断b
|| a||b 当a为真时，整体为true,不判断b
| a|b 不管a真假，b都要判断

3、位运算
& (与)从最高位运算，运算符两个位都为1，结果才为1，否则结果为0
| (或)运算符两个位只要有一个为1，那么结果就是1，否则就为0
“~” (非)表示位为0，结果是1，如果位为1，结果是0
“^” (异或)表示的两个数的同一位，相同则结果为0，不同则结果为1

4、Scanner扫描器的使用：
创建一个扫描器：java.util.Scanner sc = new java.util.Scanner(system.in)
小数： Double d = sc.nextDouble();
字符串：String str = sc.next();
不间断的字符串： String str1 = sc.nextLine();
字符： char c = sc.next().charAt(0);

====4、分支和循环=

5、分支结构的使用和分类、

① if(){......}else{.....}
②if(){ }else if(){ }else if(){} else{}
③选择结构： switch(变量/表达式/布尔){ case1 ...; case2 ...; case3 ...;  default...;}switch中可以用default和break来反回   default是结束语句，break是跳出当前循环，执行循环下面的语句， continue是跳出“本次”循环，开始下一次循环。
④while(布尔表达式){}                                         //执行0~n次  先判断在执行
⑤do while..代码块1 do{代码块2}while(布尔表达式)；代码块3        //执行1~n次，先执行在判断首先执行代码块1，在执行代码块2，判断布尔，为真时执行代码块2，否则执行代码块3
⑥for(循环变量;循环条件;循环变量的改变){}

======5、函数=
1、概念：函数是能够实现特定功能的一段代码，可以反复利用
2、好处：1、减少代码的冗余，提高代码的可读性
2、提高代码的复用性
3、提高代码的可维护性
4、代码更具有结构性，便于分工
3、函数三要素：函数名+参数表+返回值类型

4、return关键字：用来将某个数据返回给函数的调用者看；return相当于函数执行结束，后边的代码将不执行

函数的递归：
1、概念：从实用角度看，一个函数调用自己被称为函数的递归(用来解决多个同种类型的简单问题)
案例;利用递归解决阶乘问题
public static void main(String[] args){
int i = fact(n);
system.out.println(i);
}

public static int fact(int n){           //计算n的阶乘int result=0;                      //当n=4时  走else下边的  result=4*fact(4-1);->4*fact(3)  if(n==1){                         //然后再调用 fact(int n)   此时n=3;       result=4*3*fact(2)result=1;                       //  最终的结果就是4*3*2*1=24}else{result=n*fact(n-1);}return result;
}

===6、数组=

1、概念：数组是计算机内部一块连续的存储空间,用来存储多个相同类型的数据
2、使用：声明一个数组->自定义空间长度->元素初始化->访问数组

 int[] arr; , int []arr;,  int arr[];int[] arr1 = new int[5];   //定义一个长度为5的数组遍历arr1for(int i=0;i<arr1.length;i++){system.out.println(arr1[i]);}

3、数组之间的地址传递：
①数组名中存储的是数组这块连续空间的首地址 (数组的首地址=system.out.println(数组名))
②通过数组的首地址和数组的下标，按照数组的寻址算法可以定位数组的任意一块独立空间
③寻址算法：首地址+数组下标数组类型所占字节数
4、可变长数组：当一个函数不确定需要几个同种类型的参数时，可以使用可变长参数
public static void test(数据类型…数组名){}
5、数组的扩容：
①扩一个更大的数组 //int[] newarr1 = new int[arr1.length2]
②将老的数组值传递给新的数组 //遍历旧数据组 for(int i=0;i<arr1.length;i++){
//把值赋给新数组 newarr1[i] = arr1[i]; }
③新数组给老数组赋值(吧数组名赋予) //arr1 = newarr1
6、JDK提供的数组扩容工具：
java.util.Arrays.copyOf(要扩容的旧数组，新数组长度)
7、排序的方式：冒泡排序和选择排序
①冒泡排序：
int[] a = {3,2,4,1,9};
for(int i=1;i<=a.length‐1;i++){ //控制比较的轮数
for(int j=0;j<=a.length‐1‐i;j++){ //控制参与比较的左边元素的下标
//进行判断左边的元素是否大于右边的元素
if(a[j]>a[j+1]){ //如果左边大于右边则交换左右元素的位置
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
②选择排序
int[] a = {3,2,4,1,9};
for(int i=1;i<=a.length‐1;i++){ //控制轮数
for(int j= ;j<=a.length‐1;j++){ //控制每轮和固定下表进行比较的递增下标
if(a[i‐1]>a[j]){ //固定下标和递增下标对比
int temp = a[i‐1];
a[i‐1] = a[j];
a[j] = temp;
}
}
}
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
JDK提供的排序方式：排序方法：Arrays.sort(aaa);

二维数组：在数组中的每一个元素又是一个数组
定义二维数组：数组类型[][] 数组名;
例：int [a][b]a=new int[][]; //a和b分别代表的行和列
建立一个五行四列的表： arr=new int[5][4];
2、二维数组的遍历 //先遍历外层的，在遍历内层的
for(int i=0;i<a.length;i++){
for(int i=0;j<a[i].length;j++){

}}

=======================================================================================================
jvm中的即时编译：
a、jdk中编译器是前端编译器，用来将.Java文件编译为.class文件
b、目前JDK使用的JVM叫hotspot虚拟机，也称为热点型虚拟机，他会将频繁编译使用的代码编译为热点码
c、当一个函数或者循环体，连续执行达到1500次以上时，会启动第一种编译器c1(JLT编译器)，此时编译器将会把这段代码译为本平台的二进制代码从而提高执行效率,当执行超过10000次时会启动c2(JIT),不仅进行二次编译，而且自动进行代码优化
思考：在什么情况下 a+1<a；当a处于临界值时，a+1会转换为负值

=====7、面向对象

1、对象：一切客观存在的事务都被称为对象
2、面向对象的思想：从对象入手,找到问题的所有对象通过对象之间的关系解决问题
3、对象的特征是：属性。对象的功能是：方法。

4、类是对象的模板，对象是类的实例。

成员变量和局部变量的区别？
成员变量局部变量
默认值有默认值与数组一致没默认值，要先声明在使用
申明位置类以内方法以外方法，自定义代码块，初始代码块中
作用范围至少在本类中使用定义行开始，到定义代码块结束

命名同一个类中，成员变量不可重名相同作用范围不可重名

常量池 -128-127 在这个范围内的i1i2 为true 不在这个范围是 i1i2 为false

 方法重载(overload)                              方法覆盖(override)

a、方法名必须一致 a、方法名参数表必须一致
b、参数列表必须不一致(参数个数,位置,类型) b、返回值类型可以一致，也可以是父类返回值类型的子类
c、和其他无关 c、访问权限修饰符，可以等同父类或者更宽
d、异常的请求(抛出的异常可以相同或者更细或不抛出)
重载的好处：屏蔽了方法参数之间的差异问题

构造方法：构造方法必须和类名保持一致,没有返回值类型(连void都没有)
构造方法不可以手动调用，而是在JVM自己调用(在创建对象时),没有写构造方法时系统默认分配一个无参构造,自己定义了构造方法时
无参构造失效，需要手动构造无参构造
作用：往往用来给属性进行赋值
public
2.This和super关键字
1)This 引用，代表当前对象（相当于“我”）,this. 用于在构造方法或普通方法中，调用当前对象的属性或方法,
this() 只能用在构造方法中，用于调用该类中的其它构造方法。
2)Super 引用，代表直接父类对象。Super.用在子类的构造方法或普通方法中，
调用父类的属性或方法。Super()只能用在子类的构造方法中，用于调用父类的构造方法

对象创建的过程：
Ⅰ 先开辟空间,给属性赋默认值 (第一次赋值,不可控)
Ⅱ 按照初始化代码块，给属性赋初始值 (第二次赋值,可控)
Ⅲ 执行构造方法的内容 (第三次赋值,可控)

子类对象创建对象的过程：
Ⅰ 先给子类父类都分配空间,赋默认值
Ⅱ 递归构建父类对象,自上而下,依次初始化父类属性并且执行父类构造方法的代码
Ⅲ 子类属性初始化
Ⅳ 执行子类构造方法的内容

8种基本数据类型赋值时,是值的传递,引用了行赋值时是地址传递

8、面向对象三大特性封装,继承,多==

1、封装(属性私有化)private：尽可能的屏蔽类的内部构造，对数据的访问和输出加以权限(get/set)
2、继承(子类继承父类)extends：将多个类之间的共性抽取出来,形成一个新类，这个类就是父类

父类---子类     一般类---特殊类     基类---衍生类    超类----子类

3、访问权限修饰符：
本类本包非同包子类非同包非子类
private 对
默认的(default) 对对
protected 对对对
public 对对对对
4、多态：父类引用指向子类对象
父类引用指向不同的子类对象，从而引用父类的多种形态
[1]特征：a.对象始终不变
b.使用多态时,父类引用只能使用父类中的属性/方法,不能使用子类的属性或者方法
c.使用多态时,如果子类覆盖了父类的方法,那么执行的是子类覆盖后的方法
5、instance of : 引用A instanceof 引用B 组成一个布尔表达式,用来判断引用A的对象和B的兼容性
6、多态的好处：
a、屏蔽了子类之间的差异,是代码变得灵活
b、解耦合协同开发
耦合：两个类之间关系密切,在书写一个类之前要等另一个类先写完,这种关系称之为类与类之间强耦合关系
解耦合：将强耦合变成弱耦合关系

弱耦合：俩个类之间的关系有其他内容维护,俩个类分开写

三大修饰符：abstract(抽象的), static(静态的), final(最终的)
abstract:修饰类,方法
static：修饰静态资源属性,方法
final：修饰变量,类,方法
2、常见的抽象类问题、
a、如果一个类中有抽象方法,那么这个类一定是抽象的
b、如果一个类中没有抽象方法,那么这个类一定不是抽象类？
一个抽象类中可以没有抽象方法,一个类的方法可以是非抽象方法
3、static
被static修饰的属性和方法成为：静态成员=静态方法+静态属性
*三大修饰符都不可以修饰构造方法
不可以一起使用的修饰符：final abstract，static abstract ，private abstract
23.简述 final finalized finally 的区别?
1)Final修饰符

2)Finalized 垃圾回收在释放对象占用的内存之前，垃圾收集器会调用对象的 finalize()方法。一般建议在该方法中 释放对象持有的资源。3)Finally
finally代码一定会执行  Try{
逻辑代码  有可能出现异常的代码
Return 程序的出口
}catch(){
捕获异常  打印异常信息
}Fianlly{
一定会之行的代码
}

==========================================================================================================
4、类加载
意义：类加载-当第一次使用某个类的时候JVM会按照classpath(jdk环境配置)的目录去寻找对象的.class文件
并且将该.class文件(父类属性/方法/类变量…)读取到JVM中(内存中),保存待用
过程：加载–>连接(验证–准备–解析)–>初始化–>使用–>卸载
加载：将.class文件从硬盘读取到JVM内存中
–验证：验证.class文件的合法性和安全性
连接 --准备：给变量分配空间,并赋默认值
–解析：将符号引用代替为直接引用
初始化：对类变量进行初始化,会按照静态属性初始化的声明顺序进行
使用：使用读进来的信息
卸载：当类信息不再使用时,从内容中清除
5、类加载的认知：储存类信息-给变量分配空间赋默默认值-给类变量初始化
6、类加载进行的(什么时候会触发类加载)
a、第一次创建类对象时,会让该类的类加载进行到初始化阶段
b、第一次通过类名,静态成员的形式调用静态属性或者方法时,会让类加载进行到初始化阶段
c、子类类加载,如果父类没有类加载,会让父类先进行类加载,并进行到类加载的初始化阶段
d、依据反射创建类对象时也会触发类加载(class.forName() 来获取类对象时)

第一次创建某个类的类对象：
(1)先进行类加载
a、为父类,子类,类变量分配空间,赋默认值
b、父类静态属性初始化
c、子类静态属性初始化
(2)在进行对象的创建
a、给子类父类对象的属性,分配空间并赋默认值
b、构建递归执行父类构造方法中的内容
c、子类进行初始化执行子类构造方法的内容
()

====9、接口

接口：接口是一组规范和标准,接口的实现者和使用者都要遵循接口的标准和规范。

如果抽象类中都是抽象[abstract]方法,那么我们称这个类为接口[interface]

1、接口可以多继承,类是单继承对实现
2、接口的分类;
a、常量接口接口中没有抽象方法,都是静态公开常量
b、标记接口什么都没有,仅作为一个标记使用
c、普通接口包含了多个抽象方法
d、函数接口只有一个抽象方法的接口 @functionalInterface有这个注解
3、JDK1.8后的接口特性： default和static修饰要写方法体
且不管是default还是static 他们都要用public 来修饰

10、内部类

概念：一个类的内部还有一个类,称之为内部类
分类：成员内部类,宏泰内部类,局部内部类,匿名内部类

a、成员内部类  声明在类以内,方法以外的类内部类只可以声明非静态成员,不能声明静态成员①创建内部类对象的方法先创建外部类对象：  Other  other  = new  Other();再通过特殊的语法创建内部类：Other.Inner.inner = Other.new Inner();    //外部类类名.内部类类名.对象名 = 外部类类名.new 内部类类名();b、静态内部类被static修饰的成员内部类成为静态内部类可以声明静态成员和非静态成员①创建内部类对象的方法可以通过外部类类名.内部类类名.静态成员的形式来创建内部类的静态成员  //外部类类名.内部类类名.对象名 =new 外部类类名.内部类类名();c、局部内部类申明在方法中的类称为局部内部类(相当于一个局部变量)不可以申明静态成员,可以申明非静态成员①创建内部类对象的方法a 局部内部类只能在所申明的方法中使用b 从定义行开始到定义它的方法结束c 创建局部内部类的语法和创建普通类的一致     类名 对象名 = new 类名();d、匿名内部类匿名内部类是局部内部类的一种特殊形式如果一个局部内部类符合以下的条件,我们可以称该局部内部类为一个匿名内部类a 该局部内部类有父项,是某个子类或者接口的实现类b 该类的对象,在该类的作用范围内只被创建过一次语法：父项类型 对象名 = new 父项名(){//类中的内容}优势：保证了编程思路的连贯性        劣势：可读性太差,代码维护成本高

=lambda表达式===============
a、标准版：
（参数类型参数名）->{语法实现}
b、如果方法的实现仅有一行代码,可以不用{}
（参数类型参数名）->语法实现
c、如给类型确定,且只有一个参数时,参数表中只写参数名
参数名->一行代码; //参数名->实现方法;
d、如果一个方法的返回值可以用一个值或者表达式代替,那么可以指向表达式
(参数类型参数名)->表达式/值

=========11、常用类=

Object :称为超类,是Java中所有类的直接或间接父类

 当引用类型为Object时,它可以接收任何类型的参数

一、finalize()方法
finalize()当一个垃圾对象被GC垃圾回收器回收时会调用finalize()方法,该方法没有任何的作用,仅标志的垃圾回收
垃圾回收：当一个对象不再被任何引用所引用时,会被视为一个垃圾对象
GC垃圾回收器：一个用来清除来及对象,释放堆空间资源的回收器
GC垃圾回收器回收机制：
a、被动回收：当堆空间没有足够的空间去创建新的对象时GC会回收来及对象
b、主动回收：system.gc();主动的唤醒垃圾回收器,主动唤醒的可能不会把所有的垃圾对象回收

简述 final finalized finally 的区别?
1)Final修饰符最终的,被final修饰的变量要赋初始值
2)Finalized 垃圾回收在释放对象占用的内存之前，垃圾收集器会调用对象的 finalize()方法。一般建议在该方法中释放对象持有的资源。
3)Finally finally代码一定会执行
Try{
逻辑代码有可能出现异常的代码
Return 程序的出口
}catch(){
捕获异常打印异常信息
}Fianlly{
一定会之行的代码
}
二、getClass()方法
作用：反回一个引用中对象的真实类型
使用场景：往往用来判断俩个引用中所存对象类型是否一致
system.out.println(引用a.getClass()==引用b.getClass())

三、hashcode()方法
作用：将一个对象在内存中的地址转化为一个十进制数并返回 //User user = new User(); user.hashcode(); 返回的是十进制数
b、native修饰符：native修饰一个方法时,该方法没有实现称为本地方法,该方法的实现是由本地平台相关的语言进行实现
四、equals()方法。
a、作用：常常用来比较俩个引用类型的内容是否一致
b、==和equals()的区别
==既可以用来比较基本数据类型,又可以用来比较引用类型 //比较基本数据类型是比较值,比较引用类型是比较地址
equals()是用来比较引用类型中所存对象的内容是否一致

c、equals()的比较步骤① 验证自反性：验证当前对象和参数对象是否指向同一个地址② 验证非空性：验证参数是否为null③ 验证类型是否一致：俩个对象同一类型时才有比较的必要④ 将参数对象类型从Object强转为当前对象⑤ 属性依次比较

==12、包装类

含义：为了让Object可以统一管理所有的数据类型,JDK为8种基本数据类型提供了一种引用类型,我们称为包装类

byte   short   int      long  char        boolean  float  double
Byte   Short   Integer  Long  Character   Boolean  Float  Double基本数据类型&&包装类&&String之间的相互转换①基本数据类型->包装类，String->包装类    a、通过包装类的构造方法：           包装类型 引用名 = new 包装类类型(类型值);b、通过包装类的静态ValueOf方法      包装类型 引用名 = new 包装类类型.ValueOf(类型值);②包装类->基本数据类型, String->基本数据类型a、包装类   通过包装类的ValueOf()方法来,      包装类型 引用名 = new 包装类类型.ValueOf(类型值);b、String 先将String转化为包装类,在转化为基本数据类型    通过包装类的静态方法.pareseXXX将String 转化基本类型  String Shr = "abcda"；            int i = Integer.pareseInt(Str)③基本数据类型->String    包装类->Stringa、基本->String     将基本数据类型和空字符相加转换              String str = ""+基本类型通过String的静态方法ValueOf转化b、包装类->String   包装类和空字符相加通过String的静态方法ValueOf转化

二、包装类的缓冲区：
a、缓冲区的概念：当使用自动装箱时,使用的是包装类的ValueOf()方法,ValueOf会提供一个缓冲区,缓冲区是一个数组,数组中已提前创建好一些包装类对象，
当我们使用自动装箱时,使用的是缓冲区范围的值时,会优先使用缓冲区创建好的对象； Integer in1 = 10; Integer in2= 10;
in1.equals(in2) 结果时true
b、缓冲区的作用：减少频繁的创建对象的开支,在一定范围内合理的重复使用包装类对象,解决资源占用的问题
三、那些包装类存在缓冲区、
Byte Short Integer Long -128~127
Character 0~127
Boolean 所有true是一个对象，false也是一个对象

========String=
String中的方法介绍：
前边的基本类型是返回值类型
返回值类型
① int length() //字符串的长度
② boolean str1.equals(Object str) //判断俩个字符串的内容是否一致
③ char charAt(int index) //根据下标index寻找对应的一个字符
char c = s.charAt(0) String s= ‘sdsdsxcds’
④ int str1.indexOf(String str) //反回str 在str1中首次出现的位置下标,如果不存在则反回-1
⑤ int str1.indexOf(String str,int fromindex) //从fromindex开始查询,返回str 在str1中首次出现的位置下标,如果不存在则反回-1
⑥ String subString(int beginIndex) //截取字符串从beginIndex开始
⑦ String subString(int beginIndex,int endIndex) //截取字符串从beginIndex开始,到endIndex结束(包含beginIndex,奴包含endIndex)
⑧ String[] Split(String regex) //根据间隔符(regex)把原字符串分为字符串数组 s1.Split(,)
char[] toCharArray() //字符串转换为字符组类型
⑨ String replace(char oldchar,char newchar) //使用第二个参数代替字符中第一个参数
⑩ String intern() //获取字符串在串池中的地址
11.char[] toCharArray() //字符串转换为字符组类型
12.boolean s1.contains(s2) //判断s2是否是s1的字符串
13.boolean s1.isEmpty() //判断是否是空字符串,是为true 否则为false
14.String toLowercase() //字符串转换为小写反回
15.String toUppercase() //字符串转换为大写反回
16.String trim() //去掉字符串前后的空格
17.boolean s1.endswitch(S2) //判断字符串s1是否已s2结尾
18.boolean s1.startswitch(s2) //判断字符串s1是否已s2开头
19.int lastIndexOf(String str) //从后向前查询
20.int lastIndexOf(String str,int fromindex) //从fromindex开始向前查询

二、名词解释
a、常量池：在源文件编译后,一些字面值,关键字…这些信息会被编译到.class文件的一个区域中,这个区域称为常量池。(常量池位于.class文件中)
b、运行时常量池：在类加载后,.class文件会被读取到内存中,并且放置到该类所对应的方法区空间中,而存放.class中常量池信息的区域被称为运行时常量池.
(运行时常量池位于方法区中)
c、全局字符串常量池(串池)：串池是堆空间中一块独立空间,所有.class文件中的字符串常量,都会以字符串对象的形式存在串池中。

串池的作用：用来复用字符串对象,所有类中的字符串常量对象都会被存放在串池中,而串池内容一样的字符串对象只会有一个,当这些相同的字符串,谁先进入串池中

串池就存谁,为了保证所有代码使用一样的字符串时,使用的是一样的字符串对象。

 对空间中的串池对象不会被复用,串池中的字符串对象可以被复用

面试：**********
String str=“hello world”; String str2 = new String(“hello world”); 俩者的区别？？？
1.字符串常量的形式创建对象只会在串池中创建一个对象 (str)
2.构造方法创建对象会现在串池中创建一个对象再在堆中创建一个对象 (str2)

三、String类型可变性
a、概念：String类型一旦被创建则内容不可变如果更改内容会重新创建一个复制对象并把更改后的内容放置在复制对象中生成一个新对象。
b、为什么String是不可变的
a.在代码的层面来说：String中封装的字符数组是final所修饰的而字符数组中存的字符其实就是String的内容所以String的内容是不可变得
b.在思想的层面来说：java所有内容一样的字符串都去使用同一个串池中的对象如果一个引用试图更改该对象的内容会让所有使用该对象的引用都受到影响

三、字符串中的intern()方法:
当字符串调用intern()方法时,会先去串池中查看有没有该内容的字符串,如果有则将该串池中对象地址反回给调用者,如果没有,则将该对象存入串池,返回地址。

四、可变长字符
StringBuffer() JDK1.0出现的线程安全效率低
StringBuffer() JDK1.5出现的线程不安全效率高

①StringBuffer s = new StringBuffer("ABC");  //使用构造方法创建可变长字符
s.append("EFG")                              //使用append来拼接②StringBuilder也是这样③String和StringBuffer() 的区别？String 的长度和内容是无法改变的,StringBuilder的长度和内容是可以改变的

13、集合=

集合的概念：集合是一种容器,是用来对数据进行存储的,并且有丰富的方法来操作所存储的数据
数组和集合的区别？

数组：数组长度固定,操作繁琐,开发效率低
集合：提供了很多的方法来操作所存内容,操作简单,开发效率高

一、Collection类型的集合体系
是一个接口 Collection（是一个接口）
是一个接口 List Set
是一个类 ArrayList LinkedList Vector HsahSet SortedSet Cinterface

                                                                                         TreeSet

List集合******
a、简述ArrayList LinkedList Vector三者的区别?
ArrayList LinkedList Vector
jdk版本 jdk1.2 jdk1.2 jdk1.0
底层实现数组链表数组
线程安全不安全,效率高不安全,效率高安全,效率低
存储特点增删慢、查询快增删块、查询慢增删慢、查询快

b、List集合的特点：存储Object类型的对象, 有序有下标元素可以重复
Set集合的特点：用于存储Object类型对象, 无序无下标元素不可以重复

c、线性表(将数据惊醒持续的存储)
数组：实际上的线性查询快,增删慢
链表：逻辑上的线性查询慢,增删快【查询多,增删少,用ArrayList】【查询少,增删多,用LinkedList】

d、常用方法：
增加add; 删除remove; 修改set; 查询get
size(); //返回时集合中有多少个元素
java.lang,IndexOutOfBuondException(), //这个错误是下标越界

泛型集合：
定义：我们只想在一个指定的集合中存储指定类型的元素,那么就用需要给该集合一个合理的泛型。
ArrayList List = new ArrayList; //为集合添加一个学生泛型
在jdk1.7之后也可以这样：
ArrayList List = new ArrayList();

给集合添加泛型时：List.add(new Student(集合中的属性))

Set集合*
实现了 HashSet LinkedSet TreeSet(SortedSet) 会对所存元素进行排序
jdk版本 jdk1.2 JDK1.4 jdk1.2
线程安全不安全,效率高不安全,效率高不安全,效率高
底层结构散列结构实现散列结构+双向链表底层红黑树结果实现、

b、常用方法
增加 add; 删除 remove; 查询 contains;

Map集合============
a、Map集合中可以存储的是键值对对象,键值对分为俩个部分键(key) 值(value)
键(key) :存储Object类型的对象,内容不可以重复,没有下标,无序,（像Set集合）
值(value) :存储Object类型的对象,内容可以重复，没有下标,无序（像Collection集合）
Map集合中的实现类：
实现类 HsahMap HashTable propertis
jdk版本 jdk1.2 jdk1.0 jdk1.0
线程安全不安全,效率高安全,效率低安全,效率低
底层实现散列结构散列结构散列结构
键值对允许键值对为null 不允许键值对为空不允许为null (和配置文件使用的Map集合)

b、HashSet和HashMap的关系：
HashSet就是使用HashMap实现的,HashSet通过存入数据本身来维持去重机制,HsahMap则是通过键值对对象的key来维持去重机制,所以使用自定义类型的key时,要重写
hashCode和equals方法

c、HashMap和HashTable的区别？
HashMap允许key value同时为空线程不安全效率高 (初始长度16)
hashtable 不允许key value 为空线程安全的效率低整个表加锁

ConcurrentHashMap: java.concurrent jdk并发包
Hashtable和ConcurrentHashMap有什么分别呢？它们都可以用于多线程的环境，
但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。
因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，对表进行分段加锁16段
而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，
而Hashtable则会锁定整个map。

d、LinkedMap: jdk1.4出现效率高线程不安全底层散列+双向链表(可以记录键值对的存储顺序)
TreeMap: 底层又红黑树实现,会依据键的信息对键值进行排序

e、常用方法
增加和修改：put(key,value) 删除： remove(key) 查询: get(key) size() 获取所存键值对的个数

         返回类型                    方法
键(key)   ：   Set集合                       .keyset():  获取所有的键并形成一个新的Set集合
值(value)： Collection<key>              .Value()        获取所有的值形成一个Collection集合
键值对     Set<map.Entry<key,value>>    entrySet()   获取所有键值对,形成一个Set集合

Map集合的遍历********
HsahMap map = new HashMap<String,String>();
注意：map集合的遍历没有直接通过forEach遍历,forEach是Collection类型集合提供的,所以我们要把Map转换为Set捉着Collection在进行遍历
键遍历： Set keyset = map.keyset(); 然后再用forEach遍历keyset
值遍历： Collection value = map.Value(); 然后再用forEach遍历value
键值对遍历;
①：获取所有的键值对对象,键值对对象的泛型是Entry<泛型1,泛型2> Set<Entry<String,String>> entryset = map.entrySet();
②：进行forEach遍历
for(Entry<String,String>,entry:entryset){
③：分别取key value
String key=entry.getKey();
String value=entry.getValue();
}

========14、异常Exception

1、定义：在执行的过程中出现的非正常的现象
2、异常的处理：程序运行的过程中,可能会出现一些异常,这些往往会对用户造成损失,为了避免我们需要做出相应的处理。
3、处理方式：①异常抛出 throws ②try{}catch(Exception e){}
4、异常和错误的区别：

         异常是程序员可以解决的问题,错误是底层原理的问题,程序员无法通过代码解决

5、异常的分类：①运行时异常( RuntimenException) ClassCastException IndexOutOfBuondException NullPointerException ArithmeticException
未检查异常
②非运行时异常() SQLException IoException ExFException FileNotFoundException
以检查异常
6、异常的产生：手动和自动
手动：throw new 异常名(“对异常的描述”)
自动:当程序运行遇到错误时,就会产生异常

==15、IO流=

1、持久化：将内存中的数据存储到其他设备中(硬盘),用于长久的保存数据
2、IO流：数据传输的管道/通道
3、分类：输入流(往内存中写)inputStream 输出流(从内存中写到外部)outputStream

一、字节流(FileInputStream字节输入节点流，||| FileOutputStream字节输出节点流)
FileInputStream in = new FileInputStream();
FileOutputStream out = new FileOutputStream(String name, boolean append);
第一个参数，也是指定信息输出到哪个文件的路径，
第二个参数为布尔类型当第二个参数为false时输出内容会覆盖掉源文件内容，当第二个参数为true时会在源文件中追加内容
1、常用方法：
void write(int b); //每次向外写出一个字节的内容写出的内容就是参数
void close(); //关闭流释放资源
如何把一个文件中内容读完？
while(true){
int read = is.read(); //循环什么时候结束？当读到文件最后没有内容时读取结束
if(read==‐1){
break;
}
System.out.println((char)read); }
2、文件路径书写规范：
①.因为\在java是一种特殊的字符所以需要使用转义字符，将\写成\: 例：E:\CoreJava\15.IO\笔记\test.txt 改成 E:\CoreJava\15.IO\笔记\test.txt
②.或者可以把所有的\换成/: 例：E:\CoreJava\15.IO\笔记\test.txt 改成 E:/CoreJava/15.IO/笔记/test.txt
③.绝对路径与相对路径：绝对路径：从盘符写起来寻找文件路径例：E:\CoreJava\15.IO\笔记\test.txt
相对路径：直接写文件夹或文件名会默认从项目的根目录进行文件的查询，这是一种相对路径的写法例： b\a.txt 从项目的根目录去查找 b文件夹下的a.txt

3、文件拷贝
public static void main(String[] args) throws IOException {
//现有一个输入流再有一个输出流 //输出入流的路径写的是需要被复制的文件的路径
FileInputStream is = new FileInputStream(“E:\CoreJava\15.IO\视频\2.字节输出流.wmv”);
//输出流的路径写的是复制到哪里的路径
FileOutputStream os = new FileOutputStream(“C:\Users\Administrator\Desktop\晖哥牛逼的课.wmv”);
//包装过滤流
BufferedOutputStream bos = new BufferedOutputStream(os);
BufferedInputStream bis = new BufferedInputStream(is);
//使用增强功能读一个写一个
while(true){
int read = bis.read();
if(read==‐1){
break;
}
bos.write(read); }
//释放资源
bos.close();
bis.close();
}

4、字节过滤流中的缓冲流(BufferedInputStream和BufferedOutputStream)
使用过滤流的流程：
①：先创建节点流
②:给节点流包装过滤流
③：使用加强的读写功能
④：关闭流释放资源
BufferedOutputStream为写操作提供了一个8192字节的缓冲区;在写缓冲的什么时候会进行一次交互,把缓冲区内容写道硬盘中？
①：当该流被关闭时,缓冲区会和硬盘进行交互
②：当缓冲区写满时,缓冲区会和硬盘进行交互
③：当调用缓冲区的flash()方法时,缓冲区会和硬盘主动交互
BufferedInputStream为读操作提供一个8192字节的缓冲区;在读缓冲的什么时候会进行一次交互？
①：当进行第一次读取时,会先将缓冲区读满
②：后续读取不在和硬盘最交互,缓冲会和硬盘最交互,当缓冲区被读满时,主动和硬盘交互

*缓冲区的好处
好处：较少内存和硬盘的交互次数,从而提高Io效率

5过滤流 printStream
printStream提供了丰富的向【外输】出不同数据类型的功能
FileOutputStream io = new FileOutputStream(“文件路径”); //创建节点流

printStream pio = new printStream(io);                      //加装printStream包装过滤流pio.println("输出内容");                                  //使用加强的读写功能;pio.close();

6、过滤流 ObjectInputStream 和 ObjectOutputStream
定义：提供了八种基本数据类型的读写,提供了对String类型的读写,还有序列化和反序列化的支持,提供缓存功能
使用ObjectInputStream进行文件读取时要注意：读到文件的末尾不再是一个特殊值而是一个抛出一个java.io.EOFException来表明文件读到末尾代码案例：
while(true){
try{
double readDouble = ois.readDouble();
System.out.println(readDouble);
}catch(EOFException e){
System.out.println(“文件读到末尾”);
break;
}
}

7、对象的序列化问题
对象序列化(输出)：将对象放置在流中从内存传输到其他设备中的过程被称为对象序列化、需要使用ObjectOutputStream writeObject（Object obj）；
对象反序列化(输入)：将对象放置在流中从其他设备中读取到内存的过程被称为对象反序列化需要使用ObjectInputStream readObject（）；
对象序列化的注意事项：
1.注意序列一个对象时，要保证它所对应的类实现了Serializable接口
2.如果不想让对象中的某个属性参与序列化那么可以让该属性被transient所修饰
3.如果一个对象的属性是引用类型，那么必须保证该属性所对应的类型实现了Serializable接口
4.在进行集合的序列化时，要保证集合的泛型是可序列化的

8、编码：
a、编码：将符号通过字符集转换为数据的过程称为编码
b、解码：将数据通过字符集转换为符号的过程称为解码
注意：在编码和解码的过程中使用不同的字符集可能会出现乱码

二、字符流(字符输入流[Reader]和字符输出流[Writer]) 读入写出
字符流的顶级父类是 Writer和Reader 他们都是抽象类不能创建对象如果想使用字符留的输入输出功能需要使用其子类创建对象

1、字符节点流 FileReader和FileWriter
a、FileReader提供最基本的输入功能,
read(); 读单个字符
close(); 关闭流释放资源

b、FileWriter提供最基本的输出功能,write(String str);    写入字符串close();   关闭流释放资源

2、字符流拷贝文件：
//创建一个字符输出流字符输入流
//指定复制的目标文件读入
FileReader reader = new FileReader(“E:\CoreJava\15.IO\笔记\test2.txt”);
//目标文件复制的路径和新文件名写出
FileWriter writer = new FileWriter(“E:\CoreJava\15.IO\笔记\test2‐copy.txt”);
//读一个字符写一个字符
while(true){
int read = reader.read();
if(read==‐1)break;
writer.write(read);
}
//释放资源
reader.close();
writer.close();

3、字符过滤流BufferedReader/PrintWriter
字符过滤流与字节过滤流的使用流程是一样的
a.BufferedReader：提供了更强大读取文本文件的功能
常用方法：
String readLine() 读取一个文本行。读到末尾时，返回值为null
void close() 释放资源关闭流
b.PrintWriter: 提供了更强的输出字符串的能力
常用方法：
println系列方法将参数的字符串表示形式输出并换行
void close() 释放资源关闭流
c.字符过滤流把一个文本文件读完的代码：
while(true){
String line = br.readLine();
if(line==null)break;
System.out.println(line);
}

4、桥转换流
①：概念：可以将字节流转换为字符流并指定字符流的编解码使用的字符集 InputStreamReader/OutputStreamWriter
②：桥转换流的使用流程：
1.先创建一个字节流
2.再使用桥转换流将字节流转换为字符流并设置字符集
如果是输入流则设置字符集是解码的字符集 new InputStreamReader(字节输入流,解码的字符集);
如果是输出流则设置字符集是编码的字符集 new OutputStreamWriter(字节输出流,编码的字符集);
3.可以给字符流添加过滤流方便操作
4.释放资源
使用实例：
桥转换流设置解码格式：
FileInputStream is = new FileInputStream(“E:\CoreJava\15.IO\笔记\test4.txt”); //先创建一个字节流
Reader reader = new InputStreamReader(is,“UTF‐8”);//再使用桥转换流将字节流转换为字符流并设置字符集
BufferedReader br = new BufferedReader(reader); //以给字符流添加过滤流方便操作
while(true){ //读取所有的
String line = br.readLine();
if(line==null)break;
System.out.println(line);
}
br.close(); //释放资源

File类=
IO流：用来操作文件的内容
File类：用来对文件和文件夹进行操作,比如创建一个文件或者文件夹,删除等等
关于File对象的含义
new File(文件/文件夹的路径);
参数中的文件/文件夹的路径在系统中真实存在： File就相当于系统中真实存在的文件可以对文件进行删除更名等操作…
参数中的文件/文件夹的路径在系统中不存在：可以做一些创建的操作
关于File的常用方法：
public boolean CreatNewFile(); //创建文件 true是成功 flase是失败
mkdic(); //创建文件夹
delete(); //删除文件或者文件夹
renameto(File f) //修改文件名
SetReadOnly(); //文件设置为只读
getName(); //获取文件名或者文件夹名
exists(); //判断文件或者目录是否存在
getAbsolatepath(); //获取绝对路径
public File[] listFiles(); //获取当前文件下的所有的文件
isFile(); //判断是文件而不是目录
isPirectory(); //判断是目录而不是文件

16、线程==

1.什么是线程？

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。            (一个进程中至少有一个线程)
程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。
比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。
高并发：状态   多线程 线程安全  数据一致

2.什么是线程安全？Vector是一个线程安全类吗？
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。
如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。
很显然你可以将集合类分成两组，线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。

3、线程的组成： cpu+数据
cpu:一个线程执行时是需要cpu，cpu有时间片,那个线程有时间片,哪个线程就使用cpu，(时间片有os管理分发)
数据：栈空间独立：线程的逻辑方法独立
堆空间共享：所有线程共享一个堆空间
每一个线程都有自己的jvm栈,
4、现成的创建方法： 3种方法
一；1)继承Thread
Thread1 extends Thread {
public void run(){
// 线程的功能代码
}
}
使用：a. 创建线程对象
Thread1 t1 = new Thread1();
b. 启动线程
t1.start(); // 启动线程，JVM自动调用run方法
// t1.run(); //error. 相当于调用了一个对象中的方法
二、实现Runnable 接口
Thread2 implements Runnable{
//实现run方法
@Override
public void run(){
//线程的代码功能
}
}
三、3.实现 Callable 接口

对于其他线程的创建和开启，一般都要依赖于某一个线程（主线程）所以创建线程开启线程的代码，往往放置在主函数中

5、线程的sleep()方法和wait()方法的区别？
1)sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间（休息），把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复，时间到了会继续运行。
2)调用sleep不会释放对象锁。
3)wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待队列
只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

6、线程的六种状态：
①：new 初始化状态创建一个新的线程
②：RUNNABLE 运行时状态
③：BLOCKED 阻塞状态
④：WAITING 无限期等待状态
⑤：TIMED_WAITING 有限期等待
⑥：TERMINATED 终止状态

7、线程池
①：线程池中存放了一定数量的线程,这些线程可以重复利用,不必频繁的创建和销毁线程。
②：线程池的好处：不必频繁的创建和销毁线程,节省系统资源提高开发效率
③：线程池的类型：
a.线程池的顶级接口：Executor
b.线程池的实际类型：ExecutorService
c.线程池官方实现类：ThreadPoolExecutor 官方实现类构造方法的七个参数需要自己学习

②：创建从线程池对象：  2种      实现类 和  工厂方法创建1、从Java中接口类型创建           1.创建官方的实现类对象 2.调用官方的工厂方法，直接获取接口类型的对象 而不用自己手动创建2、工厂方法创建           (工厂方法：是使用某些手段去创建一个接口类型的对象，该方法的返回值就是一个接口类型（实现类）的 对象)工厂创建的方法：1.创建一个线程池 (ThreadPool)                ExecuterService threadPool = Executors.newCachedThreadPool();ExecutorService threadPool1 = Executors.newCachedThreadPool(); 2.使用线程池的submit(Runnable task)来提交任务 xecutorService threadPool1 = Executors.newFixedThreadPool(2);     //线程池的容量时2Runnable task1 = ()‐>{ for (int i = 0; i <30; i++) { System.out.println("壮壮冲马桶"); }try {//Thread.sleep(10000);                //睡10s钟} catch (InterruptedException e) {e.printStackTrace(); } };Runnable task2 = ()‐>{ for (int i = 0; i < 30; i++) { System.out.println("壮壮洗厕所"); }try {//Thread.sleep(10000);               //睡10s钟} catch (InterruptedException e) {  e.printStackTrace(); } };threadPool1.submit(task1); threadPool1.submit(task2);

8、线程安全的问题
1、名词解释：
①：原子操作：多步操作视为一个整体,执行顺序不可以被打破
②：临界资源：在多线程的情况下,多个线程共享的某个数据被称为临界资源
③：线程不同步：在多线程并发下,原子操作被破坏,临界资源出现问题
④：线程同步:在多线程下,保证原子操作不被破坏,保证临界资源数据安全
⑤：死锁：俩个线程互相等待对方释放占用的资源, 互斥锁表标记,从而使俩个线程都进入阻塞状态,是程序无法向下执行

2、lock锁同步代码块一临界资源的互斥锁标记作为占据林子资源的标记方法：上锁：lock();        解锁：unlock();         trylock();一般的上锁和解锁之间的代码都是原子操作lock锁的好处: 使得所具有更具体的表现,代码可读性高,并可以提高代码的灵活性,提高程序效率

====17、反射

类对象：当虚拟机进行类加载时会将读进的信息保存在类对中并放置在堆里类对象对应的模板叫做Class 类的对象以某个类为模板创建出的对象我们称之为类的对象

1.通过反射获取类对象的3种方式？

 1)通过类名.class 获取 Class对象Class s = Student.class;2)创建对象，通过对象 . getClass() 获取Class对象Strudet student = new Student();Class s = student.getClass();3)通过 Class.forName("包名.类名"); 获取Class对象Class s = Class.forName(“java.util.HashSet”);

设计模式：是一些经常被人使用,被多数人知晓,且被分类编目的程序设计了经验的总结

①.单例：一个类所创建出的对象在JVM内存中只有一个，那么该类所创建出的对象是单例的
②.多例：一个类所创建出的对象可以再JVM内存中有多个，那么该类所创建出的对象就是多例的

1.饿汉式
class Student{
private static final Student stu = new Student();
private Student(){} //私有构造
public static Student getInstance(){
return stu;}}
优点：在多线程条件下并发效率很高
缺点：资源利用率不高

2懒汉式
class Student{
private static Student stu;
private Student(){} //私有构造
public synchronized static Student getInstance(){
if (stu == null){
stu = new Student();
}
return stu;
}

优点：资源利用率比较高
缺点：在多线程条件下 并发效率很低

3静态内部类式
class MyClass{
static class Inner{
public final static MyClass mc = new MyClass();
}
public static MyClass getMyClass(){
return Inner.mc;
}
private MyClass(){}
}
结合了懒汉式与饿汉式即保证了资源利用率又保证了并发效率

Java一阶段大概复习相关推荐

Java虚拟机知识点快速复习手册（上）
前言本文快速回顾了常考的的知识点,用作面试复习,事半功倍. 上篇主要内容为:虚拟机数据区域,垃圾回收下篇主要内容为:类加载机制面试知识点复习手册全复习手册文章导航 Csdn全复习手册文章导航: ...
Java并发知识点快速复习手册（下）
前言本文快速回顾了常考的的知识点,用作面试复习,事半功倍. 面试知识点复习手册已发布知识点复习手册 Java基础知识点面试手册快速梳理23种常用的设计模式 Redis基础知识点面试手册 Java ...
java语言程序设计期末复习综合练习题_Java语言程序设计期末复习综合练习题答案...
Java语言程序设计期末复习综合练习题一.选择题. 2． main方法是Java Application程序执行的入口点,关于main方法的方法头以下哪项是合法的( )? A.public stat ...
java - 第一阶段总结
java - 第一阶段总结递归递归:能不用就不用,因为效率极低 package over; //递归 public class Fi {public static void main(String ...
java每个阶段的学习时间_每个Java学习者都会犯的10个最常见的1个错误
java每个阶段的学习时间据说:"您的朋友会吞下您的错误,您的敌人会将它们呈现在盘子上". 我绝对不是你的敌人,但我想向您介绍一些针对每个Java初学者的错误,我将在此博客&qu ...
[渝粤教育] 西南科技大学高级语言程序设计（Java）在线考试复习资料
高级语言程序设计(Java)--在线考试复习资料一.单选题 1.下列哪一个包给出了Runnable接口的定义?( ) A.iava.util B.java.io C.java.lang D.java ...
java第一阶段知识_第一阶段 Java语言（下）
本课程是Android入门教程之Java核心技术阶段,是Java开发高级部分,安卓开发中的基础知识,讲解以下内容: (一)反射与内省讲解了什么是反射,反射在应用中的作用,相关反射的API,如Clas ...
从JVM入手，聊聊Java的学习和复习！
我们在学习的时候,经常会遇到这样一个问题: 「学完就忘」这个问题大部分人都会遇到,那么我们今天就来聊聊,为啥会学了就忘呢? 我根据自己的学习经验,大致总结以下三点原因: 1.知识没有用起来 2.没有 ...
java工具类应该抛异常吗,java学习阶段一工具类（异常）
java学习阶段一工具类(异常) 介绍异常:运行期间出现的错误背离程序本身意图的表现基本知识异常的分类根类 Throwable Error 程序无法处理的错误表示运行应用程序中教严重的问 ...

Java一阶段大概复习

======一、Java的基础知识=

=二、变量的概念：======

short s1 = 1; s1 = s1 + 1; 有错，(s1+1 运算结果为int类型，需要强制类型转换)short s1 = 1; s1 += 1; 没有错的

2、引用类型/对象类型
String(字符串)数组均为引用类型
“A”—>字符串 ‘A’---->字符 //单引双引的区别

2、&&(短路与)与&(非短路与),||(短路或)与|(非短路或)
a&&b，a&b, a||b, a|b
&&： a&&b 都为真时整体为真，a为false时，不判断b
& a&b 都为真时整体为真 a为false时，判断b
|| a||b 当a为真时，整体为true,不判断b
| a|b 不管a真假，b都要判断

====4、分支和循环=

===6、数组=

=====7、面向对象

子类对象创建对象的过程：
Ⅰ 先给子类父类都分配空间,赋默认值
Ⅱ 递归构建父类对象,自上而下,依次初始化父类属性并且执行父类构造方法的代码
Ⅲ 子类属性初始化
Ⅳ 执行子类构造方法的内容

8、面向对象三大特性封装,继承,多==

====9、接口

10、内部类

=========11、常用类=

==12、包装类

13、集合=

d、常用方法：
增加add; 删除remove; 修改set; 查询get
size(); //返回时集合中有多少个元素
java.lang,IndexOutOfBuondException(), //这个错误是下标越界

========14、异常Exception

==15、IO流=

16、线程==

====17、反射

Java一阶段大概复习相关推荐

最新文章

热门文章

Java一阶段大概复习

======一、Java的基础知识=

=二、变量的概念：======

short s1 = 1; s1 = s1 + 1; 有错，(s1+1 运算结果为int类型，需要强制类型转换)short s1 = 1; s1 += 1; 没有错的

2、引用类型/对象类型 String(字符串)数组均为引用类型 “A”—>字符串 ‘A’---->字符 //单引双引的区别

2、&&(短路与)与&(非短路与),||(短路或)与|(非短路或) a&&b，a&b, a||b, a|b &&： a&&b 都为真时 整体为真，a为false时，不判断b & a&b 都为真时 整体为真 a为false时，判断b || a||b 当a为真时，整体为true,不判断b | a|b 不管a真假，b都要判断

====4、分支和循环=

===6、数组=

=====7、面向对象

子类对象创建对象的过程： Ⅰ 先给子类父类都分配空间,赋默认值 Ⅱ 递归构建父类对象,自上而下,依次初始化父类属性并且执行父类构造方法的代码 Ⅲ 子类属性初始化 Ⅳ 执行子类构造方法的内容

8、面向对象三大特性 封装,继承,多==

====9、接口

10、内部类

=========11、常用类=

==12、包装类

13、集合=

d、常用方法： 增加add; 删除remove; 修改set; 查询get size(); //返回时集合中有多少个元素 java.lang,IndexOutOfBuondException(), //这个错误是 下标越界

========14、异常Exception

==15、IO流=

16、线程==

====17、反射

Java一阶段大概复习相关推荐

最新文章

热门文章

2、引用类型/对象类型
String(字符串)数组均为引用类型
“A”—>字符串 ‘A’---->字符 //单引双引的区别

2、&&(短路与)与&(非短路与),||(短路或)与|(非短路或)
a&&b，a&b, a||b, a|b
&&： a&&b 都为真时整体为真，a为false时，不判断b
& a&b 都为真时整体为真 a为false时，判断b
|| a||b 当a为真时，整体为true,不判断b
| a|b 不管a真假，b都要判断

子类对象创建对象的过程：
Ⅰ 先给子类父类都分配空间,赋默认值
Ⅱ 递归构建父类对象,自上而下,依次初始化父类属性并且执行父类构造方法的代码
Ⅲ 子类属性初始化
Ⅳ 执行子类构造方法的内容

8、面向对象三大特性封装,继承,多==

d、常用方法：
增加add; 删除remove; 修改set; 查询get
size(); //返回时集合中有多少个元素
java.lang,IndexOutOfBuondException(), //这个错误是下标越界