《java编程思想》读书笔记

2017-01-17  本文已影响441人  任怂

前言

看了这本书两遍，第一遍是很大略的看了一下，里面的代码都没怎么仔细研究，粗略的看。而第二遍属于比较细致的看了，里面的代码和练习题也都研究和敲了敲。
首先这本书我觉得适合有一些项目经验然后来学习思想的来看，因为书里不会具体去将语法，所以不适合零基础入门书。而且觉得这本书确实有助于加强对java语言的理解，特别是运行机理。
以下是我对这本书的做的一些笔记，自己认为比较重要的点。当然因人而异。从泛型开始后面的章节没有看，因为难度较大，而且做项目中，泛型和容器，I/O等等暂时涉及的不是很多，理解不是很透彻，等今后做过相应项目再来研究一下。同事老程序员说他们泛型那也看不太懂所以也不太建议我研究，当然泛读一下是很好的。

思想

java编程思想更多的是告诉设计一样语法的目的，为何设计这样的语法，然后再使用时候就会更清楚。什么时候用，应该怎么用，使用的目的。
自己想到一句话我觉得不错：java中的对象成员和方法和人其实很相似：明确自己拥有什么，能干什么。

第一章：对象导论

第二章：一切都是对象（Everything is an Object)

第三章：操作符（operators）

第四章：控制流程(Controlling Execution)

第五章 初始化与清理(Initialization and Cleanup)

public enum Spiciness {
  NOT, MILD, MEDIUM, HOT, FLAMING
  
}
for(Spiciness s : Spiciness.values())
      System.out.println(s + ", ordinal " + s.ordinal());
  }
  /* Output:
NOT, ordinal 0
MILD, ordinal 1
MEDIUM, ordinal 2
HOT, ordinal 3
FLAMING, ordinal 4
*///:~

Random rand = new Random(47);//获得随机数，当参数47时获得最随机的数，而如果不传参数，则每次随机数都不同，传参每次返回一个固定的随机数。
System.out.println(rand.nextInt(150));
System.out.println(Math.random());

第六章：访问权限控制(Access Control)

class Soup2 {
  private Soup2() {}
  // (2) Create a static object and return a reference
  // upon request.(The "Singleton" pattern):
  private static Soup2 ps1 = new Soup2();
  public static Soup2 access() {
    return ps1;
  }
  public void f() {}
}

第七章：复用类(Reusing Classes)

public class SprinklerSystem {
  private String valve1, valve2, valve3, valve4;
  private WaterSource source = new WaterSource();//组合的使用

System.out.println(sprinklers);

class BoardGame extends Game {
  BoardGame(int i) {
    super(i);
    print("BoardGame constructor");
  }
}   

class Instrument {
  public void play() {}
  static void tune(Instrument i) {
    // ...
    i.play();
  }
}

public class Wind extends Instrument {
  public static void main(String[] args) {
    Wind flute = new Wind();
    Instrument.tune(flute); // Upcasting
  }
}
//这里接收的Instrument可以是Instrument的所有导出类，把wind引用转换为Instrument的动作叫做向上转型。他是安全的。


class Insect {
    private static int x1 = printInit("static Insect.x1 initialized");
    private int k = printInit("Insect.k initialized");
    private int i = 9;
    protected int j;
    Insect() {
        print("i = " + i + ", j = " + j);
        j = 39;
    }
    private static void pringgt(){
        System.out.println("静态方法");
    }
    static int printInit(String s) {
        print(s);
        return 47;
    }
}
public class Beetle extends Insect {
    private static int x2 = printInit("static Beetle.x2 initialized");
    private int k = printInit("Beetle.k initialized");
    public Beetle() {
        print("k = " + k);
        print("j = " + j);
    }
    public static void main(String[] args) {
        print("Beetle constructor");
        Beetle b = new Beetle();
    }
   /* static Insect.x1 initialized
    static Beetle.x2 initialized
    Beetle constructor
    Insect.k initialized
    i = 9, j = 0
    Beetle.k initialized
    k = 47
    j = 39

    这段代码注意以下几点：
    1）编译器会首先寻找Main方法，找到之后先执行static成员变量。
    然后执行Main方法，在创建对象的时候先执行父类的成员变量和构造
    然后执行子类的成员变量和构造
    当静态方法没有被调用的时候是不执行的。
    */

第八章：多态(Polymorphism)

Instrument[] orchestra = {
      new Wind(),
      new Percussion(),
      new Stringed(),
      new Brass(),
      new Woodwind()
    };

class TwoMethods {
    public int f1 = 4;
    public void m1() {
        System.out.println("Inside m1, calling m2");
        m2();
    }
    public void m2() {
        System.out.println("Inside m2");
    }
    public static String staticGet() {
    return "Base staticGet()";
  }
}
class Inherited extends TwoMethods {
    public int f1 = 6;
    @Override
    public void m2() {
        System.out.println("Inside Inherited.m2");
    }
    public static String staticGet() {
    return "Derived staticGet()";
  }
}
public class ex09 {
    public static void main(String args[]) {
        TwoMethods x = new Inherited();
        x.m1();
        System.out.println(x.f1);
        System.out.println(sup.staticGet());

    }
}
//Inside m1, calling m2
//Inside Inherited.m2
//4
//Base staticGet()
m1方法还是会调用子类的m2方法，java总是会调用most-derived也即最子类的覆盖方法。
如果子类和父类有相同的成员变量，但是这不是多态，多态针对方法，这里调用的还是父类的成员变量。一般不会这么写，因为成员变量一般用private.
静态方法是跟类关联的也没有多态性。

第九章：接口(Interfaces)

第十章：内部类(Inner Classes)

public class Parcel3 {
  class Contents {
    private int i = 11;
    public int value() { return i; }
  }
  class Destination {
    private String label;
    Destination(String whereTo) { label = whereTo; }
    String readLabel() { return label; }
  }
  public static void main(String[] args) {
    Parcel3 p = new Parcel3();
    // Must use instance of outer class
    // to create an instance of the inner class:
    Parcel3.Contents c = p.new Contents();
    Parcel3.Destination d = p.new Destination("Tasmania");
  }

class Parcel4 {

  private class PContents implements Contents {
    private int i = 11;
    public int value() { return i; }
  }
  protected class PDestination implements Destination {
    private String label;
    private PDestination(String whereTo) {
      label = whereTo;
    }
    public String readLabel() { return label; }
  }
  public Destination destination(String s) {
    return new PDestination(s);
  }
  public Contents contents() {
    return new PContents();
  }
}

public class TestParcel {
  public static void main(String[] args) {
    Parcel4 p = new Parcel4();
    Contents c = p.contents();
    Destination d = p.destination("Tasmania");
    // Illegal -- can't access private class:
    //! Parcel4.PContents pc = p.new PContents();
  }
} ///:~


public class Parcel7 {
  public Contents contents() {
    return new Contents() { // Insert a class definition
      private int i = 11;
      public int value() { return i; }
    }; // Semicolon required in this case
  }
  public static void main(String[] args) {
    Parcel7 p = new Parcel7();
    Contents c = p.contents();
  }
} ///:~
//这段代码表示“创建一个继承自Contents的匿名类的对象”


public class Parcel7b {
  //内部类，实现Contents
  class MyContents implements Contents {
    private int i = 11;
    public int value() { return i; }
  }
  //创建一个方法返回Contents类型
  public Contents contents() { return new MyContents(); }
  
  public static void main(String[] args) {
    Parcel7b p = new Parcel7b();
    Contents c = p.contents();//调用此方法返回一个内部类的实现
  }
} ///:~
//此端代码为上一段代码的完整形式

匿名内部类后面加上分号。
如果定义一个匿名内部类，并且希望他使用一个在其外部定义的对象，那么编译器会要求其参数引用是final 的。但是JDK1.8在不用final修饰的时候竟然也可以通过编译，因为1.8把他默认设置为final的了。

第十一章：持有对象(Holding Your Objects)-集合

//不必知道具体的迭代器需要遍历的序列类型
 public static void display(Iterator<Pet> it) {
    while(it.hasNext()) {
      Pet p = it.next();
      System.out.print(p.id() + ":" + p + " ");
    }
    System.out.println();
  } 
  public static void main(String[] args) {
    ArrayList<Pet> pets = Pets.arrayList(8);
    LinkedList<Pet> petsLL = new LinkedList<Pet>(pets);
    HashSet<Pet> petsHS = new HashSet<Pet>(pets);
    TreeSet<Pet> petsTS = new TreeSet<Pet>(pets);
    display(pets.iterator());
    display(petsLL.iterator());
    display(petsHS.iterator());
    display(petsTS.iterator());
  }

Set

    Set set = new HashSet();
    set.add("Bernadine");
    set.add("Elizabeth");
    set.add("Gene");
    set.add("Elizabeth");
    set.add("Clara");
    System.out.println(set);
    Set sortedSet = new TreeSet(set);//然后把集作为TreeSet来处理。

//entry用来迭代map
Map<String, String> map = new HashMap<String, String>();
map.put("111", "aaa");
map.put("222", "bbb");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}

第十二章：异常处理

第十三章：字符串

   String str = "hello,world!";
        String result = "";

        for (int i = 0; i < loopCount; i++) {
            result += str;
        }
    //实际上是下面的代码
     String str = "hello,world!";
        String result = "";

        for (int i = 0; i < loopCount; i++) {
            result = new     StringBuilder(result).append(str).toString();
        }

所以当很多次进行连接的时候，会不停的创造StringBuilder对象从而影响性能，而这时如果使用一个StringBuilder来创建对象用append连接则只生成一个对象，很大的提高效率。

数组
上一篇 下一篇

猜你喜欢

热点阅读