【资料图】



JRE支持.class文件，不能对.java .jsp编译为class文件



标识符 _ $



关键字

transient volatile





char 2个 字节 16位

1.4E-14 = 1.4*10^-14



八进制 0开头 包括0-7

16进制 0x或0X 包括0-9 a-f A-F

整形默认是 int

l L

浮点型默认是Double

D d

F f



字符型可以用 'A' '65' 'a' '97' '\uxxxx'



7位标准ASCII码 128种字符 表示大小写字母、标点符号、美式英语控制字符

8位扩展ASCII码 256种字符（后128位）表示特殊符号、外来语言字母

Unicode编码 支持世界所有字符集

'\uxxxx'





数值型 + 字符型 = 字符型转换为数值型进行计算

数值型 + 字符串型 = 连接运算

字符串 + 数值型 / 数值型 = 由于/优先级更加高，先除后字符串连接

变量可用中文表示

科学计数法只能用于浮点型

double d=1.23E5 // d=123000.0 = 1.23*10^5

float f=1.23e5f



double 转float会丢失精度

int long 转 float会丢失精度

long 转double会丢失精度

浮点型位数过多输出会用科学计数法表示

表示位数过多时精度不准确





单精度的长度问题，最后一位的计算结果被忽略了

不考虑最后一位

小数点后最多保留7位

这里是8位了

因为精度不够造成了数据丢失

需要使用BigDecimal类了



局部变量必须初始化才能使用



分子分母都是整形 商为整形

13/5=2

分子或分母有一个是浮点型 商为浮点型Double

13.0/5=2.6

求余数都有整形 结果为整形

13%5=3

求余数有一个浮点型 结果为浮点型

1 3.5%5=3.5D



前++ 先自增后赋值

后++ 先赋值后自增

'A' > 'B' 为false  比较的是ASCII

float f=5.0f

long l=5

f==l 结果为true 只要相等



关于 && 与 ||

a && b：a和b同时为true 才返回 true， 否则返回false；a || b：a或b任意一个为true 就返回true ， 否则返回false



还要运算 所以n=4



不用运算 所以n=3





boolean?():()



运算符优先级() ! ++ -- * / % + - >= <= > < == != && & || | = *= += -= %= /=

()最高

=最低





switch是一个常量值

char byte short int Character Byte Short Integer String enum

new Scanner(System.in)

scanner.next()





(int)(Math.random()*10+1)











一维数组

int[] array;

int array[];

int[] array;

array = new int[10];

int[] array = new int[10];

int[] array = new int[]{1,2,3,4}

int[] array = new int[]{};

int[] array = {1,2,3,4}

int[] array = {};

array.length

array[array.length-1]



增强型for循环

for(:)

冒泡排序



二维数组

int[][] array

array = new int[3][3]



int array[][]

array = new int[3][] 只指定行数

array[0] = new int[3]

array[1]  = new int[4]



int[] array[]



int[][] array = new int[][]{{1,2,3},{1,2}}

int[][] array = new int[][]{{},{},{},{}} 4行

int[][] array = {{1,2},{1,2,3}}

int[][] array = new int[][]{};无列

int[][] array = {};



array.length 行数

array[0].length 第一行的列数



可变参数不能定义在第一位 一个方法只能有一个可变参数

可以将数组传递给可变参数

数组作为参数不能传递可变参数



(int,int...)

(int,int[]) 报错 不能重载



(int,int...)

(int,int)

(1,2)调用的不是可变参数



scanner.nextInt()

正确处理异常



声明对象时 栈空间为null

new时堆空间开辟了内存 栈持有堆空间的地址引用





没有指定构造方法 系统会自动添加构造方法

进入构造方法名第一行 this实例对象产生



赋值给本身了





可以定义与构造方法同名的普通方法



在本类调用方法可加this 可不加

构造方法可以调用构造方法

this() 要放在构造方法第一行





封装增加了防御性编程

package包需要放在第一行 只能有一个



报错



加载有指定Cat类的包

*下有Cat类



跟顺序无关 还是加载有指定Cat类的包





只能显示的加载













定义静态成员属性为斜体

可以用对象名访问静态成员

但应该用类名访问

静态就是静态地址 各个对象公用同一个静态地址

局部变量不能加static  只能加final



静态方法 不能调用非静态的 成员方法 成员属性不能使用 this不能使用

需要使用就需要实例化

{} 普通代码块 构造代码块

构造代码块每次实例化都会调用

static{}静态代码块只会调用一次



局部变量在{} 作用域内



-表示private

+表示public



子 类中 this可以访问父类非private成员

可以继承静态成员

构造方法不能被继承 不能被重写

不能重写静态方法







super 不能调用 自己的 private 成语

ClassLoader.loadClass(String name) 加载字节码到JVM中 形成一个Class类





子类会默认调用父类的无参构造方法

当父类定义了构造方法 没有了无参构造方法 所以默认要提供一个无参构造方法

就要在子类显示 调用





不能并存







Object 类

没有重写equals String 比较内容是否相同 在桶里比较

equals 就是 ==

toString 打印普通对象标识 String打印字符内容

hashCode 普通对象返回的是对象标识 String返回的是与字符相关的标识 一般用于放在哪个桶



比较两个对象的属性是否相等







final + 类 代表 没有子类

final + 方法 不能被重写 可被继承

final + 局部变量 不能被修改

final + 成员基本类型属性 不能被修改

final + 对象类型 引用不能被修改 内容可修改

不能用在构造方法

final 修饰 只能在 定义时 构造代码块 构造方法静态代码块 赋值

提高性能





编译时去掉 @Override



编译时注解 源码 .class文件都有

@Autowired 运行时注解

元注解 注解的注解



饿汉式





懒汉式 线程不安全



可提高性能





instanceof 运算符 只要这个类兼容这个 类型 就会返回true



抽象类是JVM来 实例化的



抽象方法不实现要变成抽象类 含接口

包含抽象方法的类的是抽象类

抽象类 可以没有抽象方法

static final private 不能与 abstract 并存



类外使用对象名访问private成员不能访问









接口中的 final 需要在定义的时候初始化

接口成员属性 默认是 public static final 成员属性名 = 赋值



接口静态常量可通过 接口名 或者 接口变量名 调用

INet.TEMP

inet.TEMP

可以在实现类中直接通过TEMP调用

public class ImplementsClass implements INet{

{

System.out.println(TEMP);

}

}



可以在实现类实例化的时候通过对象名.TEMP调用

ImplementsClass implementsClass;

implementsClass.TEMP;

接口中的静态属性可以被实现类继承 因为这跟继承父类的时候 调用方式一样



没有重写属性这一说法

静态方法不能被重写



抽象方法只能被重写

不重写必须子类定义为抽象类 被继承下去了



接口默认方法可以带方法体 用 default 修饰

接口静态方法可以带方法体



默认方法可被子类重写

INet.super.connection(); 调用接口的默认方法

接口中的默认方法可以被继承



接口静态方法可以使用 接口名.静态方法名调用

INet.stop(); 调用接口中的静态方法 父类也可以

不能通过接口的变量名去调用静态方法 而父类可以

接口不能通过实现类的对象名去调用 而父类通过子类对象名调用可以

接口中不能通过在实现类里面直接用接口中的静态方法名调用 而父类通过在子类里面可以直接通过父类的静态方法名去调用

接口中的静态方法 不能被实现类 和子接口 继承





一个类实现两个接口有默认同名的方法

类需要重写该默认同名方法 否则报错

重写后调用的是类重写的

父类成员方法有和两个接口同名的默认方法

子类不用重写调用 父类的成员方法

调用的是父类成员方法

如果子类重写了该方法，那么调用的是子类的方法



子类继承一个父类和实现两个接口都定义了同名静态成员属性常量

直接访问同名静态成员属性常量名会报错

而子类只继承一个父类的时候可以直接调用父类的静态成员属性常量

子类实现单接口也是可以直接调用静态成员属性常量

只能在子类重写同名静态成员属性常量名

父类和两个接口的同名静态成员属性常量调用多种方式就失效了



一个子接口继承两个父接口有同名的默认方法

子接口需要重写同名的默认方法 单个就不用



成员内部类 普通内部类



在外部类方法内访问内部类

{

new Heart().temp = 12;

}

内部类实例化



Person.Heart myHeart = new Person().new Heart();



Person lili = new Person();

Person.Heart myHeart2 = lili.new Heart();



lili.getHeart();(在getHeart方法里面 return new 内部类名();)



可以在内部直接调用父类成员（直接用名字）如果出现同名字就访问内部类的

Person.this.age 直接访问外部类

public class outerClass{

int age;



public class innerClass{

public void method(){

System.out.println(age);外部类

}

}



public class innerClass{

int age;

public void method(){

System.out.println(age);内部类

System.out.println(Person.this.age);外部类

}

}

}





静态内部类



new Person().eat() 静态内部类访问外部类非静态成员 必须用实例化的方式

Person.age 访问外部类的静态成员

静态内部类访问静态内部类的实例成员不需要静态修饰 外部访问需要





在外部类方法内访问静态内部类

{

new Heart().temp = 12;(在外部类方法内)

}



Person.Heart myHeart = new Person.Heart();

Person.Heart myHeart2 = new Person().getHeart(); 在外部类方法 return new Heart();

Person.Heart.say();访问静态内部类的静态成员方法





方法内部类 局部内部类

类不能定义static 不能用访问修饰符

在外部类的方法里面定义class 关键字

可以使用 abstract final





public Object getHeart() {

abstract/final class Heart {

public String beat() {

new Person().eat();

return Person.age;

}

}

return new Heart().beat();

}



Person lili = new Person();

lili.getHeart(); 只能使用Object里面的方法





匿名内部类



不能使用构造方法

可以使用构造代码块

不能使用静态成员

匿名内部类是在定义里的方法参数内部使用的

需要在外部main方法中调用这个方法

jdk7前需要final

jdk8后匿名内部类访问外部局部变量不需要使用final 但在匿名内部类内部不可改变它



peopleTest1.getRead(new Person(){

{

// 构造代码块

}

@Override

public void reat(){

System.out.println("男生喜欢看科幻类书籍");

}

});















finally也不能执行了



finally 中有return 只会返回finally的

当 try 或cache中有return

finally中没有return 遇到return 会先执行完finally里的代码块 后执行 try cache中的return



多个,





抛出的异常两个 A I 无法捕获到 因为这里 抛出的是Exception 需要捕获为抛出的类的本类 或者父类 不能是兄弟类 子类



public int test(){



throw new Exception();

}







throw new的类 在throws

只能是throw new的本类父类，不能是兄弟类

不能是子类

Throwable是Exception的父类









throws只能是父类或者相同的类型也就是本类





自定义异常 继承Exception

在构造方法 调用 super("异常描述")





在要抛出的异常方法使用 throw new 自定义异常 类



捕获异常使用自定义的异常类

e.getMessage() 拿到自定义异常错误信息 Exception 以上的父类 方法





异常链



public static void main(args){

在main方法调用异常尾部最后一个方法

捕获异常

打印所有异常信息

}

第一个方法抛出自定义异常



被第二个方法调用第一个方法 捕获到异常

抛出一个新的异常

throw new Exception("异常信息",e);



被第三个方法调用第二个方法捕获 到异常

抛出一个新的异常

Exception e1 = new Exception("异常信息");

e1.initCause(e);

throw e1



异常重写问题

异常是自定义异常 继承 Exception

父类的方法 throws 自定义异常

父类的方法里面是抛出 throw 自定义异常



子类重写

方法 throws 自定义异常 本类

方法 throws 继承Exception的子类 也就是自定义异常的兄弟类

方法 throws 继承自定义异常的子类

方法重写的throws 必须是兄弟类（继承同一个父类）或者本类 或者子类 不能是父类







对象常量池

int t1 = 5;

Integer t2 = t1; 自动装箱 直接通过赋值 -128<=值<=127 隐式调用了 Integer.valueOf(); 不在这个范围 否则就隐式调用了new

Integer t3 = new Integer(t1); 手动装箱 通过 new 的方式



int t4 = t2; 自动拆箱 直接通过赋值

int t5 = t2.intValue(); 通过调用方法完成手动拆箱

double t6 = t2.dobuleValue(); 手动拆箱为double类型



int t1 = 2;

String t2 = Integer.toString(t1);  整形转换 为String



int t3 = Integer.paseInt(t2) 字符串转换为整形



int t4 = Integer.valueOf(t2) 字符串转换为包装类Integer 再自动拆箱为 整形



-128<=值<=127







indexOf(int)

indexOf(String)

lastIndexOf(int)

lastIndexOf(String)

indexOf(String,int)

getBytes()



new String(Byte[],String(字符集))









字符串的 equals 比较的是内容

= 比较的是引用是否相等



字符串每次改变内容 都会创建一个新的对象 原对象不变

String s = ""; 这种方式定义都会放到常量池上



new String(); 定义堆上

每次修改在堆上创建新的字符串对象



StringBuffer 线程安全

StringBuilder 性能高

默认字符容量 16



StringBuilder 每次在自己堆上改变 具有可变性







append(char)

append(String) 添加字符串

delete(int,int) 删除字符串

replace(int,int,String) 在指定 位置修改字符串

subString(int,int)

频繁操作使用StringBuilder 简单操作使用String



Math.random() 返回[0,1)

Math.random()*10 返回[0,10)

Math.random()*10+1返回[1,11)

int(Math.random()*10+1) 返回整数

Scanner sc = new Scanner(Systam.in);

sc.netxt();

数组.length



Set表示集

ArrayList数组序列 长度动态增长的数组

LinkedList链表

HashSet哈希集

HashMap哈希表





list 是可以重复的有顺序的

ArrayList 底层是动态数组

优点

尾部添加 或 删除数据 效率高

适合查找和修改

元素可以为null

初始化容量为10个元素

add(Object) 添加元素

add(int,Object) 从第 int条 后面添加元素

size() 长度

get(int) 查询元素

remove(int)删除元素

set(int,Object) 从 第int条 替换元素



Date 类

new Date() 返回当前时间













开源笔记

可 Pull Requests 协作写开源笔记

如果笔记图片无法访问 请访问 teambition 原版开源笔记

gitee

https://gitee.com/opendevel/java-for-linux

github

https://github.com/OSrcD/java-for-linux

teambition

https://tburl.in/0jDNvpbK

开源视频

bilibili

https://space.bilibili.com/77266754

开源博客

oschina

https://my.oschina.net/u/4675154

csdn

https://blog.csdn.net/OpenDevel

开源项目

gitee

https://gitee.com/opendevel

github

https://github.com/OSrcD

开源赞赏