《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.如果是抽象类而不是接口,那么只有内部类才能实现多继承。