1,组合(composition):
新的类由现有的类的对象组成,这种方法称为组合;
2,继承:按照现有类的类型来创建新类,无需改变现有类的形式。
3,带参数的构造器
class Game {
Game(int i) {
print("Game constructor");
}
}
class BoardGame extends Game {
BoardGame(int i) {
super(i);//调用父类构造器
print("BoardGame constructor");
}
}
public class Chess extends BoardGame {
Chess() {
super(11);//调用父类构造器
print("Chess constructor");
}
public static void main(String[] args) {
Chess x = new Chess();
}
} /* Output:
4,名字屏蔽
如果java的基类拥有某个已被多次重载的方法名称,那么在导出类中重新定义该方法名称,不会屏蔽其在基类中的任何版
本,这与c++不同。因此,无论在该层或它的基类中对方法进行定义,重载机制都可以正常工作。
class Homer {
char doh(char c) {
print("doh(char)");
return 'd';
}
float doh(float f) {
print("doh(float)");
return 1.0f;
}
}
class Milhouse {}
class Bart extends Homer {
void doh(Milhouse m) {
print("doh(Milhouse)");
}
}
public class Hide {
public static void main(String[] args) {
Bart b = new Bart();
b.doh(1);
b.doh('x');
b.doh(1.0f);
b.doh(new Milhouse());
}
} /* Output:
输出结果是:
doh(float)
doh(char)
doh(float)
doh(Milhouse)
jdk5中新增加了@Override注解,它不是关键字,但是可以当做关键字使用。当你想要覆盖某个方法时,可以
选择添加这个注解,在你不小心重载而并非覆盖了该方法时,编译器会报错。
class Lisa extends Homer {
@Override char doh(char c) {
System.out.println("doh(Milhouse)");
return 'd';
}
} ///:~
5,final关键字
1 final 数据
- 一个永不改变的编译时常量;
- 一个在运行时被初始化的值,你不希望它被改变。
一个既是static又是final的域只占据一段不能改变的存储空间。
对于基本类型,final使得数据恒定不变,而对于对象引用,final使引用恒定不变,一旦引用被初始化指向一个对象,就无
法再把它改为指向另一个对象。然而,对象其自身却是可以被修改的。
class Value {
int i; // Package access
public Value(int i) { this.i = i; }
}
public class FinalData {
private static Random rand = new Random(47);
private String id;
public FinalData(String id) { this.id = id; }
// Can be compile-time constants:
private final int valueOne = 9;
private static final int VALUE_TWO = 99;
// Typical public constant:
public static final int VALUE_THREE = 39;
// Cannot be compile-time constants:
private final int i4 = rand.nextInt(20);
static final int INT_5 = rand.nextInt(20);
private Value v1 = new Value(11);
private final Value v2 = new Value(22);
private static final Value VAL_3 = new Value(33);
// Arrays:
private final int[] a = { 1, 2, 3, 4, 5, 6 };
public String toString() {
return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5;
}
public static void main(String[] args) {
FinalData fd1 = new FinalData("fd1");
// fd1.valueOne++; // Error: can't change value
fd1.v2.i++; // Object isn't constant!
fd1.v1 = new Value(9); // OK -- not final
for(int i = 0; i < fd1.a.length; i++)
fd1.a[i]++; // Object isn't constant!
// fd1.v2 = new Value(0); // Error: Can't
// fd1.VAL_3 = new Value(1); // change reference
// fd1.a = new int[3];
print(fd1);
print("Creating new FinalData");
FinalData fd2 = new FinalData("fd2");
print(fd1);
print(fd2);
}
} /* Output:
6,空白final
指被声明为final但又未定初始值的域
class Poppet {
private int i;
Poppet(int ii) { i = ii; }
}
public class BlankFinal {
private final int i = 0; // Initialized final
private final int j; // Blank final
private final Poppet p; // Blank final reference
// Blank finals MUST be initialized in the constructor:
public BlankFinal() {
j = 1; // Initialize blank final
p = new Poppet(1); // Initialize blank final reference
}
public BlankFinal(int x) {
j = x; // Initialize blank final
p = new Poppet(x); // Initialize blank final reference
}
public static void main(String[] args) {
new BlankFinal();
new BlankFinal(47);
}
} ///:~
7,final参数
class Gizmo {
public void spin() {}
}
public class FinalArguments {
void with(final Gizmo g) {
// g = new Gizmo(); // 非法,不能修改
}
void without(Gizmo g) {
g = new Gizmo(); // OK -- g not final
g.spin();
}
// void f(final int i) { i++; } // 不能改变
// You can only read from a final primitive:
int g(final int i) { return i + 1; }
public static void main(String[] args) {
FinalArguments bf = new FinalArguments();
bf.without(null);
bf.with(null);
}
} ///:~
8,final方法
1,把方法锁定,防止任何继承类修改它的含义;
2,确保在继承中该方法保持不变,并且不会被覆盖。
类中所有的private方法都隐式的制定为final的。
class WithFinals {
// Identical to "private" alone:
private final void f() { print("WithFinals.f()"); }
// Also automatically "final":
private void g() { print("WithFinals.g()"); }
}
class OverridingPrivate extends WithFinals {
private final void f() {
print("OverridingPrivate.f()");
}
private void g() {
print("OverridingPrivate.g()");
}
}
class OverridingPrivate2 extends OverridingPrivate {
public final void f() {
print("OverridingPrivate2.f()");
}
public void g() {
print("OverridingPrivate2.g()");
}
}
public class FinalOverridingIllusion {
public static void main(String[] args) {
OverridingPrivate2 op2 = new OverridingPrivate2();
op2.f();
op2.g();
// You can upcast:
OverridingPrivate op = op2;
// But you can't call the methods:
// op.f();
//! op.g();
// Same here:
WithFinals wf = op2;
//! wf.f();
//! wf.g();
}
} /* Output:
9,final类
由于final类禁止继承,所以final类中所有的方法都隐式的指定为fina的,因为无法覆盖它们。
10,类的代码在初次使用时才会加载,这通常指加载发生在创建类的第一个对象之时,但是当访问static域或static方法
时,也会发生加载。
class Insect {
private int i = 9;
protected int j;
Insect() {
print("i = " + i + ", j = " + j);
j = 39;
}
private static int x1 =
printInit("static Insect.x1 initialized");
static int printInit(String s) {
print(s);
return 47;
}
}
public class Beetle extends Insect {
private int k = printInit("Beetle.k initialized");
public Beetle() {
print("k = " + k);
print("j = " + j);
}
private static int x2 =
printInit("static Beetle.x2 initialized");
public static void main(String[] args) {
print("Beetle constructor");
Beetle b = new Beetle();
}
} /* Output:
运行结果:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
分享到:
相关推荐
Java是一种面相对象的编程语言。计算机语言分成两种,第一种是面向机器结构的语言,构建数据模型是基于机器的结构。第二种是面向待解决问题结构的语言,构建数据模型是基于问题的结构。Java提供了更丰富的工具来描述...
java编程思想读书笔记,114页,压缩文件才39K。
Java编程思想重点笔记(Java开发必看)
Java编程思想读书笔记 doc doc
java编程思想笔记,建议与书本结合使用。。。。。。。。。。。
Java编程思想(第4版)读书笔记by CZFJava编程思想(第4版)读书笔记by CZFJava编程思想(第4版)读书笔记by CZF
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
Java并发编程学习笔记
Java编程思想重点笔记(Java开发必看)满满的干货!!!!!
Java JDK 7学习笔记 PDF
《java编程思想》学习笔记
Java编程思想读书笔记.pdf
该部分整理了 Java编程技术中所有的内容,同时附件中还给出了与c++的比较
java编程思想读书笔记.rarjava编程思想读书笔记.rar
java编程思想的笔记。是别人的学习笔记。
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记
《Java JDK7学习笔记》是作者多年来教学实践经验的总结,汇集了教学过程中学生在学习java时遇到的概念、操作、应用或认证考试等问题及解决方案。《Java JDK7学习笔记》针对java se 7新功能全面改版,无论是章节架构...
Java编程思想重点笔记(Java开发必看).pdf