java学习笔记4-thinking in java

//1.包：库单元
import java.util.*; //导入完整的实用工具(Utility)库

package mypackage;
// package语句必须作为文件的第一个非注释语句出现，该语句表示这个编译单元属于名为mypackage的一个库的一部分
// 注意根据java包（封装）的约定，名字内的所有字母都应小写。

//P.java
// the P.rint & P.rintln shorthand
package combruceeckel.tools;


public class P {
public static void rint(Object obj) {
Systemout.print(obj);
}
public static void rint(String s) {
Systemout.print(s);
}
public static void rintln() {
Systemout.println();
}
public static void rintln(Object obj) {
Systemout.println(obj)
}
public static void rintln(String s) {
Systemout.println(s);
}
}
// 所有对象和字符串数据类型都可以在一个新行输出（P.rintln()），或不在一个新行输出（P.rint()）


import combruceeckel.tools.*;

public class ToolTest {
public static void main(String[] args) {
P.rintln("Available from now on!");
}
}

//protected能使得继承的类自由访问，但friendly（默认的）却不能

//2.合成
//:Bath.java
// construction initialization with composition

class Soap {
private String s;
Soap() {
Systemout.println("Soap()");
s = new String("Constructed");
}
public String toString() {return s;}
}

public class Bath {
private String s1 = new String("Happy"),
              s2 = "Happy",
  s3,s4;
Soap castille;
int i;
float toy;
Bath() { //Initializing
Systemout.println("Inside Bath()");
s3 = new String("Joy");
i = 47;
toy = 3.14f;
castille = new Soap();
}
void print() {
if(s4==null) s4 = new String("Joy");
Systemout.println("s1="+s1);
Systemout.println("s2="+s2);
Systemout.println("s3="+s3);
Systemout.println("s4="+s4);
Systemout.println("i="+i);
Systemout.println("toy="+toy);
Systemout.println("castille="+castille);
}
public static void main(String[] args) {
Bath b = new Bath();
b.print();
}
}

//3.继承
// :Detergent.java 
// Inheritance syntax & prperties

class Cleanser { //清洁剂，洁面乳
private String s = new String("Cleanser");
public void append(String a) {s +=a;}  //添加，附加
public void dilute() {append("dilute()");} //稀释
public void scrub() {append("scrub()");} //擦洗
public void print() {Systemout.println(s);}
public static void main(String[] args){
Cleanser x = new Cleanser();
x.dilute();
x.print();
}
}

public class Detergent extends Cleanser { //洗涤剂， 洗衣粉
public void scrub() { //刷洗
append("Detergent.scrub()");
super.scrub(); //Call base-class version 
}
public void foam() { //起泡沫
append("foam()");
}
public static void main(String[] args) {
Detergent x = new Detergent();
x.dilute();
x.scrub();
x.foam();
x.print();
Systemout.println("Testing base class");
Cleanser.main(args);
}
}

//4.三级继承
//4.1 初始化构建器，且不含任何自变量
//:Cartoon.java
// Constructor calls during inheritance

class Art {
Art() {
Systemout.println("Art constructor");
}
}

class Drawing extends Art {
Drawing() {
Systemout.println("Drawing constructor");
}
}

public class Cartoon extends Drawing {
Cartoon() {
Systemout.println("Cartoon constructor");
}
public static void main(String[] args) {
Cartoon x = new Cartoon();
}
}

//4.2 含自变量的构建器
//:Chess.java
// Inheritance, constructors, and arguments

class Game {
Game(int i) {
Systemout.println("Game constructor");
}
}

class BoardGame extends Game {
BoardGame(int i) {
super(i);
Systemout.println("BoardGame constructor");
}
}

public class Chess extends BoardGame {
Chess() {
super(11);
Systemout.println("Chess constructor");
}
public static void main(String[] args) {
Chess x = new Chess();
}
}

// 合成与继承的组合
//: PlaceSetting.java
// Combining composition & inheritance

class Plate {
Plate(int i) { // 盘子
Systemout.println("Plate constructor")
}
}

class DinnerPlate extends Plate {
DinnerPlate(int i) {
super(i);
Systemout.println("DinnerPlate constructor");
}
}

class Utensil { // 器皿
Utensil(int i) {
Systemout.println("Utensil constructor");
}
}

class Spoon extends Utensil {
Spoon(int i) {
Systemout.println("Spoon constructor");
}
}

class Fork extends Utensil {
Fork(int i) {
super(i);
Systemout.println("Fork constructor");
}
}

class Knife extends Utensil {
Knife(int i) {
super(i);
Systemout.println("Knife constructor");
}
}

class Custom {
Custom(int i) {
Systemout.println("Custom constructor");
}
}

public class PlaceSetting extends Custom {
Spoon sp;
Fork frk;
Knife kn;
DinnerPlate pl;
PlaceSetting(int i) {
super(i+1);
sp = new Spoon(i+2);
frk = new Fork(i+3);
kn = new Knife(i+4);
pl = new DinnerPlate(i+5);
Systemout.println("PlaceSetting constructor");
}
public static void main(String[] args) {
PlaceSetting x = new PlaceSetting(9);
}
}

// 如果想利用新类内部一个现有类的特性，而不想使用它的接口，通常应选择合成，即我们可嵌入一个对象，使自己能用它实现新类的特性。

// protected: 本身是私有的，但可由从这个类继承的任何东西或者同一个包内的其他任何东西访问

//上溯造型：造型是从衍生类到基础类。为判断到底应该用合成还是继承，一个最简单的办法就是考虑是否需要从新类上溯造型回基础类。若必须上溯，就需要继承

//:FinalData.java
// The effect of final on fields

class Value {
int i = 1;
}

public class FinalData {
final int i1 = 9;
static final int I2 = 99; //按照规则名字全部采用大写
public static final int I3 = 39;
final int i4 = (int)(Math.random()*20);
static final int i5 = (int)(Math.random()*20);

Value v1 = new Value();
final Value v2 = new Value();
static final Value v3 = new Value();
//!final Value v4; //必须初始化，否则报错
final int[] a = {1,2,3,4,5};

public void print(String id) {
Systemout.println(id + ": " + "i4= " + i4 + ",i5= " + i5);
}

public static void main(String[] args) {
FinalData fd1 = new FinalData();
//!fd1.i1++ //不能改变常数值
fd1.v2.i++; //对象本身可以修改，但不能绑定到新的对象
for(int i = 0;i<fd1.a.length;i++)
fd1.a[i]++; //数组也属于对象
fd1.print("fd1");
Systemout.println("Creating new FinalData");
FinalData fd2 = new FinalData();
fd1.print("fd1");
fd2.ptint("fd2");
}
}