第1章--使用对象
1.1 字符类型
char c = 65; // char --> int
char c = '\u0041'; // \u: unicode + (Hex 41--> Dec 65)
char c = 'A';
escape character
'\b' --> backspace the cursor (not delete the last character, just move the cursor)
However, eclipse will ignore it
e.g.System.out.print("abc\bd");
in eclipse console: abcd
in terminal console: abd
'\n' --> 换行； '\r\ --> 回车 --> 起源于打字机：回车-->光标回到第一列；回车-->新的一行
1.2 包裹类型
基础类型 --> 包裹类型
boolean Boolean
char Character --> .isDigit(char); isUppercase(char); .toLowerCase(char); etc.
int/double Integer/Double --> Integer.MAX_VALUE
usage:
Integer i = 10;
Integer i = new Integer(10);
1.3 字符串类型
read in String:
in.next() --> separated by space (including \t, \n, etc.)
in.nextLine() --> separated by \n
String comparison:
(initialising two strings a and b)
a.equals(b) (not by using "==" to compare)
a.compareTo(b); // based on the Unicode
String some other methods:
a.charAt(int index); // get the particular char at the position index
a.substring(int index); // get the sub-string starting from position index (included)
a.substring(int start, int end); // get the sub-string from start(included) to end (excluded)
a.indexOf(char); // find the char in string a and return the position of the first found
// (-1 if char doesn't exist)
a.indexOf(char, int); // find the char, starting from position int (included)
a.startsWith(b); a.endsWith(b) // check if a starts/ends with substring b
a.trim(); // delete the spaces at two ends of the string
a.replace(c1, c2); // replace c1 with c2
a.toLowerCase(); a.toUpperCase()
NB:
instances of String are immutable !!!
1.4 Math类
some methods:
Math.abs(number); // absolute value
Math.round(number); // rounding
Math.random(); // random number between 0 and 1
Math.pow(a, b); // a to the power of b
第2章--类与对象
2.1 用类制造对象
2.2 定义类
UML for classes
2.3 成员变量和成员函数
2.4 对象初始化
initialization:
for local variable: error when using an uninitialised local variable
for object variable: auto initialisation to 0/false/null...
step into constructor:
new object;
invoke constructor automatically;
execute the initialisation code outside the constructor;
execute the code inside the constructor.
constructor overload 重载:
inside constructor: this(args);
NB: if we use this();, it must be the first (several) statement in the constructor
2.5 对象交互
low coupling - 低耦合
problem domain - 问题领域
2.6 访问属性
private: visible inside the class (here is "class" rather than "object")
eg.
public class Fraction {
private int r;
public Fraction func (Fraction b) {
a.r = b.r;
}
}
if the visibility is not set, it becomes to package-visible by default.
compilation unit 编译单元 -- each .java file could be considered as one compilation unit.
each compilation unit has maximum one public class (same name as the name of compilation unit),
(and could have zero to many classes).
2.7 包
2.8 类变量和类函数
static variable: using object or class to access the static variable inside; using static method to access the variable.
static variable will be initialised when the class is loaded （当类被装载时）
第3章--对象集合
3.1 顺序容器
It is the reference of an object that is put in the container rather than a copy of the object.
Changing the object by itself (not via the container access) will also change the object contained by the container.
3.2 对象数组
An array of objects contains the references to those object elements.
need to create each of the element. (before creation: null: NullPointerException).
For each loop:
for (int k: array) {} // each k is a copy of an element in array. -- changing k does not modify the element in array
for (Classname c: array) {} // each c is a copy of the reference to an element -- the changing does something indeed.
for each loop works for container as well.
A container variable can be System.out.print() directly -- thanks to toString();.
3.3 集合容器(set)
set: no duplicated element; no order.
HashSet<type> name = new HashSet<type>();
3.4 散列表(hash)
hash table: key-value pairs
HashMap<type, type> name = new HashMap<type, type>();
if the key in a new key-value pair exists already, it got overwriten.
traverse hashmap:
for( Integer k : map.keySet()) {
e = map.get(k);
}
第4章--继承与多态
4.1 继承
4.2 子类父类关系
|
父类成员访问属性 |
在父类中的含义 |
在子类中的含义 |
|
public |
对所有人开放 |
对所有人开放 |
|
protected |
只有包内其它类、自己和子类可以访问 |
只有包内其它类、自己和子类可以访问 |
|
缺省 |
只有包内其它类可以访问 |
如果子类与父类在同一个包内：只有包内其它类可以访问 否则：相当于private，不能访问 |
|
private |
只有自己可以访问 |
不能访问 |
public的成员直接成为子类的public的成员，protected的成员也直接成为子类的protected的成员。Java的protected的意思是包内和子类可访问，所以它比缺省的访问属性要宽一些。
父类的private的成员在子类里仍然是存在的，只是子类中不能直接访问。
不可以在子类中重新定义继承得到的成员的访问属性。
the order of initialisations:
1. parent's definition initialisations
2. parent's consturctor
3. child's definition initialisations
4. back to child's constructor
If there is no explict invoking of the super() in the child's constructor, it will automatically call the parent's constructor which has no argument passed in.
如果我们试图重新定义一个在父类中已经存在的成员变量，那么我们是在定义一个与父类的成员变量完全无关的变量，在子类中我们可以访问这个定义在子类中的变量，在父类的方法中访问父类的那个。尽管它们同名但是互不影响。
public class Item {
private String title;
public void setTitle(String s) {
this.title = s;
}
}
public class CD extends Item {
private String title;
public CD(String title) {
this.title = title; // cd-title
setTitle("aaa"); // item-title
}
}
4.3 多态变量和向上造型
class type cast:
Item item = new Item(..);
CD cd = new CD(...); // class CD extends Item
item = cd; // works fine
CD cd1= (CD)item; // type cast
Item item = new Item(...);
CD cd = (CD)item; // compiling ok, but exception is thrown when executing
cast here (造型) is different from the cast in the example (类型转换): double a = (double)b;
向上造型是默认的，也总是安全的
4.4 多态
子类中的方法取代了父类的方法--override，父类的这个方法被“覆盖”起来而看不见了。而当通过父类的对象调用这个方法时，实际上执行的仍然是父类中的这个方法。注意我们这里说的是对象而不是变量，因为一个类型为父类的变量有可能实际指向的是一个子类的对象。
当通过对象变量调用一个方法时，究竟应该调用哪个方法，这件事情叫做绑定。绑定表明了调用一个方法的时候，我们使用的是哪个方法。绑定有两种：一种是早绑定，又称静态绑定，这种绑定在编译的时候就确定了，根据变量的声明类型来决定；另一种是晚绑定，即动态绑定。动态绑定在运行的时候根据变量当时实际所指的对象的类型动态决定调用的方法。
Java缺省使用动态绑定。
4.5 类型系统
单根结构：Object class
toString() can have super.toString() inside;
equals(): whether two references refer to the same object
@Override
public boolean equals(Object obj) {
CD cd = (CD)obj;
return artist.equals(cd.artist);
}
章后习题
1. 给定以下代码：
-
public class Test { private int i = f(); private int j = 10; private int f() { return j; } public static void main(String args[]) { System.out.println((new Test()).i); } }
以下哪句是正确的？
-
A. 由于在main中访问了Test的私有的变量而不能编译
-
B. 通过编译，打印出10
-
C. 由于成员变量定义初始化时的顺序错误而不能编译
-
D. 通过编译，打印出0
2. 给定以下代码：
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "Hello";
String s3 = "Hellp";
s3 = s3.replace('p', 'o');
System.out.println(s1==s2);
System.out.println(s1==s3);
}
3. 给定以下代码：
private class Base{
Base(){
int i = 100;
System.out.println(i);
}
}
public class PriBase extends Base{
static int i = 200;
public static void main(String argv[]){
PriBase p = new PriBase();
System.out.println(i);
}
}
4. 给定以下代码：
interface I {
void setValue(int val);
int getValue();
}
以下哪段代码能编译？
abstract class C implements I {
int value;
public void setValue(int val) { value = val; }
public int getValue() { return value; }
}
B.
interface A implements I {
void increment();
}
class A extends I {
int value;
void setValue(int val) { value = val; }
int getValue() { return value; }
}
class A extends I {
void increment();
}
5. 有以下代码：
public class Equivalence {
public static void main(String[] args) {
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1 == n2);
}
}
答案：
1. D
2. true, false
3. Illegal modifier for the class Base; only public, abstract & final are permitted
4. A
5. false
