Java编程思想学习笔记(二)
(美) Bruce Eckel 著 《Java编程思想》部分学习日记(随手记录的笔记)
7. 编写构造器的准则:
用尽可能简单的方法使对象进入正常状态,如果可以的话,避免调用其他方法。当然可以调用时基类的final方法或private方法。
8. final用法:
final数据:
1.一个永不改变的编译时常量
2.一个在运行时被初始化的值,而你不希望它被改变。
一般不使用final修饰引用类型,因为用处不大。
static final 域和final域的区别
代码:
import java.util.Random;
public class FindData {
private static Random random =new Random();
private static final int i =random.nextInt(100);
private final int j=random.nextInt(100);
public static void main(String[] args) {
FindData findData1=new FindData();
System.out.println(findData1.i);
System.out.println(findData1.j);
FindData findData2=new FindData();
System.out.println(findData2.i);
System.out.println(findData2.j);
}
}
输出结果:
89
77
89
26
final参数:
意味着你无法在方法中更改参数引用所指向的对象。这一特性主要用来向匿名内部类传递数据。
final方法:
把方法锁定住,以防止任何继承类修改它的含义。
9. 继承时应该注意的事项:
一个法则:
为了继承,一般规则是将所有的数据成员指定为private,所有的方法指定为public
@override注解可以防止你在不想重载时而意外地进行了重载。
带参数继承
class Game {
Game(int i) {
System.out.println("Game" + i);
}
}
class BoardGame extends Game {
BoardGame(int i) {
super(i);
// TODO Auto-generated constructor stub
System.out.println("BoardGame" + i);
}
}
public class Chess extends BoardGame {
Chess(int i) {
super(i);
// TODO Auto-generated constructor stub
System.out.println("Chess" + i);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Chess chess = new Chess(11);
}
}
10. 结合使用组合和继承:
class Plate {
Plate(int i) {
System.out.println("Plate" + i);
}
}
class DinnerPlate extends Plate {
DinnerPlate(int i) {
super(i);
System.out.println("DinnerPlate" + i);
}
}
class Utensil {
Utensil(int i) {
System.out.println("Utensil" + i);
}
}
class Spoon extends Utensil {
Spoon(int i) {
super(i);
System.out.println("Spoon" + i);
}
}
class Fork extends Utensil {
Fork(int i) {
super(i);
System.out.println("Fork" + i);
}
}
class Knife extends Utensil {
Knife(int i) {
super(i);
System.out.println("Knife" + i);
}
}
class Custom {
Custom(int i){
System.out.println("Custom"+i);
}
}
public class PlaceSetting extends Custom{
private Spoon spoon;
private Fork fork;
private Knife knife;
private DinnerPlate dinnerPlate;
PlaceSetting(int i) {
super(i+1);
spoon=new Spoon(i+2);
fork =new Fork(i+3);
knife =new Knife(i+4);
dinnerPlate =new DinnerPlate(i+5);
System.out.println("PlacceSettinig"+i);
// TODO Auto-generated constructor stub
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
PlaceSetting placeSetting =new PlaceSetting(9);
}
}
11. 一个多态和继承的例子:
public class Test {
private static void tunAll(Rodent[] rodents) {
for (Rodent rodent : rodents) {
rodent.eat();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Rodent[] ronRodents ={
new Mouse(),
new Gerbil(),
new Hamster()
};
tunAll(ronRodents);
}
}
class Rodent{
void eat(){
}
}
class Mouse extends Rodent{
void eat(){
System.out.println("老鼠");
}
}
class Gerbil extends Rodent{
void eat(){
System.out.println("鼹鼠");
}
}
class Hamster extends Rodent{
void eat(){
System.out.println("大家鼠");
}
}
一个结论:
只有非private方法才可以覆盖,但是还需要密切注意覆盖private方法的现象,这时虽然编译器不会报错,但是也不会按照我们所期望的来执行。确切地说,在导出类中,对于基类中的private方法,最好采用不同的名字。
12. 接口和工厂一个经典例子:
public class TestFactory {
/**
* @param args
*/
public static void selectFactory(CycleFactory cycleFactory) {
Cycle cycle =cycleFactory.getCycle();
cycle.ride();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
selectFactory(new FactoryUnicycle());
selectFactory(new FactoryTricycle());
selectFactory(new FactoryUnicycle());
}
}
interface Cycle {
void ride();
}
interface CycleFactory {
Cycle getCycle();
}
class Unicycle implements Cycle {
@Override
public void ride() {
System.out.println("骑单轮自行车");
}
}
class FactoryUnicycle implements CycleFactory{
@Override
public Cycle getCycle() {
return new Unicycle();
}
}
class Bicycle implements Cycle {
@Override
public void ride() {
System.out.println("骑自行车");
}
}
class FactoryBicycle implements CycleFactory{
@Override
public Cycle getCycle() {
return new Bicycle();
}
}
class Tricycle implements Cycle{
@Override
public void ride() {
System.out.println("骑三轮车");
}}
class FactoryTricycle implements CycleFactory{
@Override
public Cycle getCycle() {
// TODO Auto-generated method stub
return new Tricycle();
}}
13. 异常使用指南:
1.在恰当的级别处理问题。
2.解决问题并且重新调用产生异常的方法。
3.进行少许修补,然后绕过异常发生的地方继续执行。
4.用别的数据进行计算,以代替方法预计会返回的值
5.把当前运行环境下能做完的事情尽量做完,然后把相同的异常重抛到更高层。
6.当前运行环境下能做完的事情尽量做完,然后把不同的异常抛给更高层。
7.终止程序
8.进行简化
9.让类库和程序更安全。
14. 自定义异常:
public class InheritingExceptions {
public void f() throws SimpleException {
System.out.println("异常");
throw new SimpleException();
}
public static void main(String[] args) {
InheritingExceptions sed = new InheritingExceptions();
try {
sed.f();
} catch (SimpleException e) {
System.out.println("Caught it");
}
}
}
class SimpleException extends Exception {
}