offer Java基础精选从编译到集合

　　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'

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

　　扩展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：同时trueea和b 才返回 true， 否则，返回false;a || b：任何trueea或b的任何一个 回到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}

　　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类的包

　　加载只能显示

　　将静态成员属性定义为斜体

　　静态成员可以通过对象名访问

　　但应使用类名进行访问

　　静态是静态地址 每个对象使用相同的静态地址

　　局部变量不能添加staticcc 只能加final

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

　　如果需要使用，则需要实例化

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

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

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

　　局部变量{} 作用域内

　　-表示private

　　+表示public

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

　　静态成员可以继承

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

　　静态方法不能重写

　　super 不能调用 自己的 private 成语

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

　　默认情况下，子类会调用父类无参结构方法

　　当父亲定义了结构方法时 没有无参结构的方法 因此，默认情况下，提供一种无参结构的方法

　　必须在子类中显示 调用

　　不能并存

　　Object 类

　　equalss没有重写 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);外部类

　　}

　　}

　　}

　　offer Java基础精选从编译到集合

　　静态内部类

　　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();访问静态内部静态成员的方法

　　方法内部类 局部内部类

　　staticcccticcc类不能定义 访问修饰符不能使用

　　classs在外部类方法中定义 关键字

　　可以使用 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需要finall之前，需要final

　　jdk8后匿名内部类访问外部局部变量不需要使用finall 但是匿名内部类内部不能改变

　　peopletest1.getRead(new Person(){

　　{

　　// 构造代码块

　　}

　　@Override

　　public void reat(){

　　System.out.println(“男生喜欢看科幻书”);

　　}

　　});

　　finally不能执行。

　　finally 有return 只会回到finally

　　当 try 或者在cache中，returnn

　　finally没有returnn 遇见return finally中的代码块将首先执行 后执行 try returnnn在cache中

　　多个,

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

　　public int test(){

　　throw new Exception();

　　}

　　throw new的类 在throws

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

　　不能是子类

　　Throwable是Exception的父类

　　throws只能是父类或相同类型，即本类

　　自定义异常 继承Exception

　　使用抛出的异常方法 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 继承自定义异常子类

　　throwss方法重写 必须是兄弟(继承同一个父亲)或者这个类别 或者子类 不能是父类

　　对象常量池

　　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经常操作 使用Stringg操作简单

　　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 原始开源笔记