Thinking in java个人总结
根据规范，java类的首字母大写，方法的首字母小写，命名按照驼峰规则来
构造器（系统会自动创建一个无参构造，若已经写了（有参，无参）系统就不会创建了），方法重载，
java方法重载不考虑使用返回值来判别的原因：可能会只顾使用方法而忽略其返回值，如f()
关键字this只能用于方法内部，表示对当前对象的引用，如果想在当前方法中调用其他方法则无需this
java中的基本数据类型能从一个“较小”的类型自动提升到一个“较大”的类型（byte<short<char<int<long<float<double）
Java.util.random->Random（10）后面的种子数->当种子数相同时，产生的随机数（ran.nextInt()或nextDouble()等）将会固定，所以如果没有特殊要求就不需要固定种子数。Java.lang.Math.Random->Math.Random产生0～1之间不包括1的double类型
关系比较，==和！=比较的是两个对象的引用，比较两个对象内容用equals（），基本数据类型直接使用==或！=就行
科学计数，float a=1.39e-2f;->1.39X10-2次
位运算：&（按位与->两个1=1）；|按位或； ^按位异或（不同取1）；！取反;<<左移（低位加0）>>右移（若为正则在高位加0，若为负则在高位加1） >>>无符号右移（无论正负都加0） >>=或>>>=移动完后赋值给左边变量
java在进行高类型转低类型时会进行截尾操作（float->int 3.4->3）若想进行四舍五入操作则使用java.lang.Math->round()方法
foreach+range():for(inti:range(10))==for(int i=0;i<10;i++)
java中没有goto，但是可以用continue／break 标签(如a)来跳转到a a:System.out.print(“a”)
java进行初始化操作时，先初始化静态变量（只初始化一次）->静态变量不同于final，他是可以改变的，再初始化非静态变量
默认方法toString()打印出类名和地址
可变参数：a(Object…args)/a(int j,String…a)不确定类型和个数／不确定个数
enum枚举类型：publicenumcolor{
red(1),black(4),blue(7);
privateinta;
privatecolor(intin){
this.a=in;
}
publicintgetColor(){
returnthis.a;
}
}publicvoidtest(){
for(colora:color.values()){
System.out.println(a+"-->"+a.getColor());
}
Ø 继承了enum，可覆盖的方法（ordinal-枚举值在枚举类型中的顺序，compareTo-两个枚举值比较顺序，values-包含全部枚举值的数组，toString枚举常量名称，valueOf-指定枚举值的枚举常量，equals-比较是否是同一个引用）
Ø 如果不提供任何访问权限修饰词，则默认是“包访问权限”
Ø 默认包：处于相同的路径之中且没有给自己设置包名，处于默认包中的类可以相互访问
Ø 封装：把数据和方法包装进类中，以及具体实现的隐藏
Ø 一个编译单元只能有一个public类，外部类（顶级类）只能用public／default修饰，内部类可以用static，public，default，protected，private修饰
Ø 内部类编译之后就会形成独立的class，因此内部类变量／方法可以和外部类相同，外部类可以直接访问，内部类不能含有static（因为成员内部类先要先创建外部类才能创建自己，而static是优先创建的）
Ø public class Outer {
Ø public static void main(String[] args) {
Ø Outer outer = new Outer();
Ø Outer.Inner inner = outer.new Inner();
Ø inner.print("Outer.new");
Ø
Ø inner = outer.getInner();
Ø inner.print("Outer.get");
Ø }
Ø
Ø // 个人推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时
Ø public Inner getInner() {
Ø return new Inner();
Ø }
Ø
Ø public class Inner {
Ø public void print(String str) {
Ø System.out.println(str);
Ø }
Ø }
Ø }
Ø 在内部类使用外部类：outer.this
Ø 局部内部类：在外部类的函数中定义一个类
Ø 嵌套内部类：嵌套内部类，就是修饰为static的内部类。声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为private，一般声明为public，方便调用。
u 匿名内部类：只使用一次，且必须继承一个父类或者实现一个接口且两者不可兼得，不能定义构造函数，不能存在任何静态变量或方法，匿名内部类不能抽象，形参必须为final，初始化采用
Ø 继承父类
Ø abstract class Person {
Ø public abstract void eat();
Ø }
Ø
Ø public class Demo {
Ø public static void main(String[]args) {
Ø Personp = new Person() {
Ø public void eat() {
Ø System.out.println("eatsomething");
Ø }
Ø };
Ø p.eat();
Ø }
Ø }
实现接口
Ø interface Person {
Ø public void eat();
Ø }
Ø
Ø public class Demo {
Ø public static void main(String[]args) {
Ø Personp = new Person() {
Ø public void eat() {
Ø System.out.println("eatsomething");
Ø }
Ø };
Ø p.eat();
Ø }
Ø }
Ø thread匿名内部类实现
Ø public class Demo {
Ø public static void main(String[]args) {
Ø Threadt = new Thread() {
Ø public void run() {
Ø for (int i = 1; i <=5; i++) {
Ø System.out.print(i+ " ");
Ø }
Ø }
Ø };
Ø t.start();
Ø }
Ø }
Ø 每一个非基本类型的对象都有一个toString方法，当编译器需要一个String而你只有一个对象时就会调用toString方法，toString方法需要自己编写（返回某个属性）
Ø 在继承中，父类如果没有默认构造器只有有参构造启，子类想要调用父类的有参构造器就要使用super（i）；i是参数，super.xxx()调用父类的某个方法，在finally中要记得释放资源
Ø 子类引入新的重载方法，并不会屏蔽父类的方法
Ø 组合：在新类中嵌入某个类，让其实现所需要的功能
Ø 继承：。。
Ø 代理：
Ø protected提供了子类的访问权限以及包内的访问权限。
Ø 向上转型：新类是现有类的一种类型，可以用新类来替代父类，就像是研究生必定有本科生的技能一样，在一个方法中的参数要求传入父类-》可以用子类来替代
Ø final：基本数据（数值不变）static final会占据一段不能改变的存储空间（编译期常量），对于对象（引用不变，对象本身是可以改变的）
Ø 空白final：在类中使用，必须在构造器中用表达式对final进行赋值操作
Ø final参数，用于函数中，无法对其进行修改
Ø final方法：（1）防止继承过程中对方法进行覆盖，保持方法不变；（2）保证效率
Ø 类中的private方法都隐式的指定为final，对private增加final并没有增加额外的意义
Ø final类不能被继承，也不能做任何改变