Java编程思维学习笔记（二）

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 {
}

Java编程思维学习笔记（二）

相关推荐