《Thinking in Java》学习笔记(三)

1>Java中的常量

　　使用final和static来修饰的变量称为常量，常量用大写字母表示，字母间用下划线连接。

　　Java中定义常量有以下几种方式：

interface ConstantInterface {  
    String SUNDAY = "SUNDAY";  
    String MONDAY = "MONDAY";  
    String TUESDAY = "TUESDAY";  
    String WEDNESDAY = "WEDNESDAY";  
    String THURSDAY = "THURSDAY";  
    String FRIDAY = "FRIDAY";  
    String SATURDAY = "SATURDAY";  
}  

enum ConstantEnum {  
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY  
}  

class ConstantClassField {  
    public static final String SUNDAY = "SUNDAY";  
    public static final String MONDAY = "MONDAY";  
    public static final String TUESDAY = "TUESDAY";  
    public static final String WEDNESDAY = "WEDNESDAY";  
    public static final String THURSDAY = "THURSDAY";  
    public static final String FRIDAY = "FRIDAY";  
    public static final String SATURDAY = "SATURDAY";  
} 

　　第一种方式利用了接口(Interface)的中变量默认为static final的特性，但是不符合接口设计的初衷。

　　第三种方式如果静态变量很多时，如果我们只需要其中的一个常量，导致的结果却是整个类被加载到内存中，这点是需要注意的，特别是类中的常量很多时。

2>容器类的并发性

　　HashMap不是线程安全的，在并发的情况下可能会引起CPU占用率100%的情况，这是需要注意的。

　　HashSet底层也是用HashMap实现的，也是线程不安全的。

　　TreeMap和TreeSet也不是线程安全的。

　　解决办法有2种：

　　一是使用线程安全的版本，例如HashMap对应的ConcurrentHashMap，HashSet对应的CopyOnWriteArraySet。

　　二是使用Collections的静态方法，例如Collections.synchronizeMap()。

　　ArrayList也不是线程安全的，多线程的情况下可以使用CopyOnWriteArrayList或者Vector来代替。CopyOnWriteXXX类读时不加锁，写入时会加锁。

　　还有我们常用的StringBuffer是线程安全的，StringBuilder不是线程安全的。

3>异常和错误

　　Throwable是Java处理错误的父类。

　　Throwable的子类可以分为2类：Error和Exception。

　　Error是JVM无法预期的错误，将会导致程序的崩溃，无法修复，例如内存溢出OutOfMemoryError。

　　Exception是可以恢复的意外，是可以被捕获到的，可以被修复的。

　　出现异常后，系统会把异常一直往上抛，没有处理的代码，就会一直往上抛。最终的结果是，单线程由main方法抛出，多线程的由Thread.run()抛出。

　　我们使用try/catch来捕获并处理异常，就是希望程序不会意外的终止。

　　Java提供了2种异常机制：

　　1.运行时异常，RuntimeException，出现异常时交由虚拟机去处理。

　　2.检查式异常，编译器强行要求我们处理的异常，常见的包括I/O异常，sql异常，我们必须用try/catch来捕获并处理异常，否则无法通过编译。

　　常见的运行时异常包括：ClassCastException,DOMException,NullPointerException,IndexOutOfBoundException（数组越界）。

　　随着程序的调试，运行时异常会越来越少，程序健壮性也会越来越好。

4>接口

　　接口的修饰符可以有public和缺省的2种。

　　接口中的域默认的是public和final的，即使不去写public和final，它们也是public和final的。

　　接口中方法默认的是public的，即使不去写public，它们也是public的。

　　

　　当一个类继承自一个类又实现了接口时，继承必须被放在前面，否则会报错。

　　接口也可以继承自一个或者多个接口：interface A extends B,C。B和C是接口。

　　接口可以嵌套在其他的接口或者类中，如下：

　　

　　接口的修饰符可以有public和缺省的2种，所以会报上面的错误。

　　

public interface IA { 
    public void out();
    
}

public class SA { 
    public void out() {
        System.out.println("SA");
    }

}

public class A extends SA implements IA{  
    public static void main(String[] args) {
        new A().out();
    }

}

　　输出的结果是：SA
　　接口中的方法在实现类中都要写出来，A中里却没有，这是因为父类实现了这个方法。所以这里调用的还是父类的方法。

5>内部类

　　内部类可以是静态static的，也可用public，default，protected和private修饰。而普通类只能使用public和default。

　　内部类按使用的场景可以分为以下几种情况：

　　1.成员内部类

　　就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

　　成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己。

public class Outer {    
     public static void main(String[] args) {        
        Outer outer = new Outer();         
        Outer.Inner inner = outer.new Inner();       //注意用法  
        inner.print("Outer.new");          
     }   
  
      public class Inner {       
          public void print(String str) {            
             System.out.println(str);       
          }  
            
          public Outer getOuterInstance(){
                return Outer.this;         //注意用法
        }
   } 
} 

　　2.局部内部类

　　局部内部类，是指内部类定义在方法和作用域内。

public class Parcel4 {    
     public Destination destination(String s) {        
         class PDestination implements Destination {           
              private String label;              
              private PDestination(String whereTo) {                
                     label = whereTo;         
            }              
            public String readLabel() {                
                     return label;            
             }       
          }       
          return new PDestination(s);     
    }      
    public static void main(String[] args) {       
      Parcel4 p = new Parcel4();         
      Destination d = p.destination("Tasmania");   
  } 
}

　　局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

3.嵌套内部类

　　嵌套内部类，就是修饰为static的内部类。声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。

　　嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。

　　严格地讲，嵌套内部类不属于内部类，没有外部类对象时，也能够访问嵌套内部类。

public class StaticTest {   
　　    private static String name = "javaJohn";　          
　　　　private String id = "X001";  
　　　　static class Person{  
　　　　　　private String address = "swjtu,chenDu,China";  
　　　　　　public String mail = "josserchai@yahoo.com";//内部类公有成员   
　　　　　　public void display(){  
　　　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员   
　　　　　　　　System.out.println(name);//只能直接访问外部类的静态成员   
　　　　　　　　System.out.println("Inner "+address);//访问本内部类成员。   
　　　　　　}  
　　　　}  
　　  
　　　　public void printInfo(){  
　　　　　　Person person = new Person();  
　　　　　　person.display();  
　　　　　　//System.out.println(mail);//不可访问   
　　　　　　//System.out.println(address);//不可访问   
　　　　　　System.out.println(person.address);//可以访问内部类的私有成员   
　　　　　　System.out.println(person.mail);//可以访问内部类的公有成员   
　　  
　　　　}  
　　　　public static void main(String[] args) {  
　　　　StaticTest staticTest = new StaticTest();  
　　　　staticTest.printInfo();  
　　}  
　}  

4.匿名内部类

　　使用匿名内部类还有个前提条件：必须继承自一个抽象类或实现一个接口。

interface Person {
    public void eat();
}
 

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
   }
}

　　内部类的继承

　　内部类的继承，是指内部类被继承，普通类 extents 内部类。而这时候代码上要有点特别处理。

public class InheritInner extends WithInner.Inner {      
    // InheritInner() 是不能通过编译的，一定要加上形参     
  InheritInner(WithInner wi) {        
         wi.super();    
     } 
     
    public static void main(String[] args) {       
        WithInner wi = new WithInner();         
        InheritInner obj = new InheritInner(wi);     
     }
 }
  
class WithInner {    
     class Inner {      } 
} 

　　可以看到子类的构造函数里面要使用父类的外部类对象.super();而这个对象需要从外面创建并传给形参。

　　内部类还有一些需要注意的地方，如下：

　　1.嵌套类是可以放到接口中，默认是static的

class T2 {
  public void test() {
    IN.MyTestInner ttt = new IN.MyTestInner();
       ttt.testInner();
  }
}

interface IN {
  public void testOutter();

  // 嵌套类
  public class MyTestInner {
    public void testInner() {
      System.out.println("testInner");
    }
  }
}

　　2.每个内部类都可以独立的实现一个接口，无论这个接口是否已经被外部类所实现。

　　3.如果是抽象类而不是接口，那么只有内部类才能实现多继承。