疯狂Java讲义笔记

第1章 Java语言概述

1. Windows系统中不区分大小写，Path和PATH没有区别，Linux系统区分大小写，Path不等同于PATH。
2. 用户变量和环境变量的区别：用户变量只对当前用户有效，系统变量对所有用户有效。系统变量的路径排在用户变量的路径之前。
3. JDK1.5以上版本无需配置CLASSPATH，CLASSPATH作用：告诉JRE在什么路径下搜索Java类，一点(.)表示在当前路径下。
4. Java源文件命名规则：一个Java源文件可以包含多个类定义，但最多只能包含一个public类定义；如果Java源文件里包含public类定义，则该源文件的文件名必须与这个public类的类名相同。

第2章 理解面向对象

1. 常用的UML图：用例图、类图、组件图、部署图、顺序图、活动图、状态机图。
2. 用例图描述系统提供的系列功能，用例图对系统的实现不做任何说明，仅仅是是系统功能的描述。

第3章 数据类型和运算符

1. Java标识符以字母、下划线（_）、美元符号（$）开头，后面可以跟任意字母、数字、下划线、美元符号、日文字符等等。
2. Java关键字都是小写的，TRUE、FALSE等不是Java关键字。
3. 4种整型byte:占8位；short占16位；int占32位；long占64位。
4. 二进制的整数以0b开头，例如int binVal=0b1001;等于int binVal=9;。
5. 补码计算规则：正数的补码和原码相同，负数的补码等于反码加1。反码是对原码按位取反，最高位（符号位）不变。
6. 一种随机字符串验证码生成方式：先随机生成int数字，再强制转换成char类型：int intVal=(int) (Math.random()*26+97);//随机生成97~122之间的整数。

第5章 面向对象（上）

1. 类名命名规则：类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不使用任何分隔符。
2. Field名命名规则：由一个或多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不使用任何分隔符。
3. 方法名命名规则：与Field命名规则基本相同，但建议方法名已英文中的动词开头。
4. 定义类的修饰符：public、final、abstract。
5. 定义Field的修饰符：public、protected、private（三选一）、static、final。
6. 定义方法的修饰符：public、protected、private（三选一）、abstract、final（二选一）、可以和static组合起来。
7. 在类中定义的成员，有static修饰的成员属于类本身，没有static修饰的成员属于该类的实例。
8. Java里的方法不能独立存在，必须定义在类里，方法必须属于类或对象。
9. 同一个类的一个方法调用另一个方法时，如果被调方法时普通方法，则默认使用this作为调用者；如果被调方法是静态方法，则默认使用类作为调用者。
10. 使用static修饰的方法可以被该类或该类的任何对象来调用，但得到的执行结果都是一样的；不使用static修饰的方法被不同的对象调用会得到不同的结果。
11. Java方法的参数传递方式：值传递。
12. 形参个数可变的方法：在定义方法时，在最后一个形参（只能写在最后，一个方法中最多只能包含一个长度可变的形参）的类型后增加三个点（...），则表明该形参可接收多个参数值，参数值被当做数组传入。形参可变的参数实际上就是一个数组。

    public class JavaClass{
        
        public static void read(String... books){
            for(String book:books){
                System.out.println(book);
            }
        }
        public static void main(String[] args){
            read("Java","C#","ASP","JSP");
        }
    }

    该代码执行结果如下：

    $ java JavaClass
    Java
    C#
    ASP
    JSP

13. 成员变量无需显示初始化，局部变量除了形参之外都必须显式初始化，否则不可以访问。
14. 访问控制级别：

    	private	default	protected	public
    同一个类中	√	√	√	√
    同一个包中	√	√	√	√
    子类中			√	√
    全局范围内				√

15. 通过import导入类：import package.subpackage...ClassName；导入指定包下的全部类：import package.subpackage...*;此时不能导入该目录的子目录里的类。
16. Java的子类不能获得父类的构造器。
17. 重载主要发生在同一个类的多个同名方法之间（有时也会出现在父类方法和子类方法之间），重写发生在子类和父类的同名方法之间。
18. 构造器的重载（super和this）
    1. super调用的是去父类的构造器

       class Base{
           public double size;
           public String name;
           public Base(double size,String name){
               this.size = size;
               this.name = name;
           }
       }
       class Sub extends Base{
           public String color;
           public Sub(double size,String name,String color){
               super(size,name);
               this.color=color;
           }
       }

    2. this调用的是同一个类中重载的构造器

       class Apple{
           public String name;
           public String color;
           public double weight;
           
           public Apple(){
               //无参构造器
           }
           public Apple(String name,String color){//两个参数的构造器
               this.name = name;
               this.color = color;
           }
           public Apple(String name,String color,double weight){//三个参数的构造器
               this(name,color);
               this.weight = weight;
           }
       }

19. 初始化块是构造器的补充，在构造器之前执行，可用初始化块来对进行对象的初始化，但是初始化块不能接收任何参数。
20. 初始化快的修饰符只能是static，成为静态初始化块，静态初始化块比普通初始化块先执行，用于对整个类进行初始化。

第6章 面向对象（下）

1. String类的多个重载ValueOf()方法用于将基本类型变量转换成字符串，比如

   String stStr = String.ValueOf(2.345f);
   String boolStr = String.ValueOf(true);

   将字符串类型的值转换为基本类型的值可利用包装类提供的parseXxx(String s)静态方法或者Xxx(String s)构造器，比如

   String intStr = "112";
   int it1 = Integer.parseInt(intStr);
   int it2 = new Integer(intStr);

2. toString()方法时Object类里的一个实例方法，所有的Java类都是Object类的子类，所有的Java对象都有toString()方法。
3. 有抽象方法的类智能被定义成抽象类，抽象类里可以没有抽象方法。
4. 定义抽象方法只需在普通方法上增加abstract修饰符，并把普通方法的方法体包括花括号全部去掉，并在方法后增加分号。
5. abstract修饰类时表明这个类只能被继承，当abstract修饰方法时表明这个方法必须由子类提供实现（重写）；而final修饰的类不能被继承，final修饰的方法不能被重写，因此abstract和final永远不可同时使用。
6. abstract关键字修饰的方法必须被其子类重写才有意义，因此abstract方法不能被定义为private权限，即private和abstract不能同时修饰方法。
7. 接口不能包含构造器和初始化块定义，可以包含Field（只能是常亮）、方法（只能是抽象方法）、内部类（包括内部接口、枚举）定义。
8. 接口里的所有成员都是public访问权限，可以省略访问控制修饰符。
9. 不管定义接口里的Field时是否使用public static final修饰符，接口里的Field总将使用这三个修饰符。
10. 不管定义接口里的方法时是否使用public abstract修饰符，接口里的方法总是使用public abstract来修饰。（接口里的内部类、接口、枚举类默认采用public static修饰符）。
11. 一个类实现了一个或多个接口之后，必须完全实现这些接口里所定义的全部抽象方法（重写）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。
12. Java不允许在外部类的静态成员中直接使用非静态内部类，比如以下代码是违法的。

13. public class Static{
      private class In{}
      public static void main(String[] args){
          new In();
         }          
    }    

    非静态内部类里不能有静态方法、静态Field、静态初始化块。

14. 静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。
15. 在外部类以外的地方创建非静态内部类实例的语法：OuterInstance.new InnerConstructor();创建静态内部类：new OuterClass.InnerConstructor();
16. 对于局部成员而言，使用static修饰没有任何意义，因此所有的局部成员都不能使用static修饰。因为所有局部成员的作用域是所在方法，所以所有的局部成员都不能使用访问控制符修饰。
17. 匿名内部类必须继承一个父类，或实现一个接口。但最多只能继承一个父类，或实现一个接口。
18. 枚举类是一种特殊的类，它一样可以有自己的Field、方法，可以实现一个或多个接口，也可以定义自己的构造器。一个Java源文件中最多只能定义一个public访问权限的枚举类，且该Java源文件也必须与该枚举类的类名相同。
19. 枚举类的构造器只能使用private访问控制符。
20. 所有的枚举类都有一个values方法，返回该枚举类的所有实例。
21. 垃圾回收机制只负责回收堆内存中的对象，在垃圾回收机制回收任何对象之前，总会先调用它的finalize()方法。
22. 对象在内存中的三个状态：可达状态、可恢复状态、不可达状态。
23. 当某个对象被其他类的类变量引用时，只有该类被销毁后，该对象才会进入可恢复状态；当被其他对象的实例变量引用时，只有当该对象被销毁后，该对象才会进入可恢复状态。