《THING IN JAVA》 7章复用类-读书笔记

最新推荐文章于 2023-11-17 18:14:11 发布

zeng8129

最新推荐文章于 2023-11-17 18:14:11 发布

阅读量224

点赞数

分类专栏：读书笔记

本文链接：https://blog.csdn.net/zeng8129/article/details/54744198

版权

读书笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1、组合语法
2、继承语法

（1）当创建一个类时总是在继承，除非已明确指出要从其他类中继承，否则就是在隐式地从Java的标准根类Object进行继承。

（2）当一个类继承另一个类时，会自动得到基类中所有的域和方法。

（3）可以为每个类都创建一个main（）方法。这种在每个类都设置一个main（）方法的技术可使每个类的单元测试都变得简便易行。

（4）即使一个类只具有包访问权限，其public main（）仍然是可以访问的。

（5）一般来说为了继承，一般的规则是将所有的数据成员都指定为private，将所有的方法指定为public，当然在特殊情况下，必须做出调整。

（6）如果在基类中想调用超类的方法，super关键字代表了超类对象，否则达不到调用的效果。

（7）在继承时关于带参数的构造器：必须用关键字super显式地编写调用基类构造器的语句，并且配以适当的参数列表，否则编译器会无法找到合适的构造器而报编译错误，并且，调用基类构造器必须是你在导出类构造器中要做的第一件事。

3、代理

（1）代理关系：Java并没有提供对它的直接支持。这是继承与组合之间的中庸之道，下面展示一个代理的例子：

//展示代理关系

public class MyTest1 {
public void f(int i){
System.out.println("i="+i);
}
}

class MyTest2 {
private MyTest1 myTest1 = new MyTest1();
public void f(int i ){
myTest1.f(i);
}
}

可以看到，我们使用代理时可以拥有更多的控制力，因为我们可以选择只提供在成员对象中的方法的某个子集。

尽管Java语言不直接支持代理，但是很多开发工具却支持代理。例如，使用JetBrains IdeaIDE就可以自动生成上面的例子。

4、结合使用组合和继承

（1）析构函数是一种在对象被销毁时可以被自动调用的函数。其原因可能是因为在Java中，我们的习惯只是忘掉而不是销毁对象，并且让垃圾回收器在必要使释放其内存。

（2）因此，如果你要某个类清理一些东西，其首要任务就是，必须将这一清理动作置于finally子句之中，以预防异常的出现。

（3）垃圾回收器可能永远也无法被调用，即使被调用，它也可能以任何它想要的顺序来回收对象。最好的办法是除了内存以外，不能依赖垃圾回收器去做任何事。如果需要进行清理，最好是编写自己的清理方法，但不要使用finalize（）。

（4）Java SE5新增加了@Override注解，它并不是关键字，但是可以把它当作关键字使用。当你想要覆写某个方法时，可以选择添加这个注解，在你不留心重载而并非覆写了该方法时，编译器就会生成一条错误消息：

public class MyTest3 {
public void f(){
System.out.println("This is the class MyTest3");
}
}

class MyTest4 extends MyTest3{
@Override
public void f(String s){ //编译错误
System.out.println("This is the class MyTest4");
}
}

@Override注解可以防止你在不想重载时而意外地进行了重载

5、在组合与继承之间选择

（1）组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情形（其实在复用代码中经常碰见这种情况，由于两个功能所包含的代码能复用，经常进行“抽类”以达到代码复用的效果），为取得此效果，需要在新类中嵌入一个现有类的private对象。

（2）“is-a”（是一个）的关系是用继承来表达的，而“has-a”（有一个）的关系则是用组合来表达的。

6、protected关键字

（1）尽管可以创建protected域，但是最好的方式还是将域保持为private

7、向上转型

（1）在向上转型的过程中，类接口中惟一可能发生的事情是丢失方法，而不是获取它们。向以下例子：

public class MyTest5 {
public void f(){
System.out.println("This is the class MyTest5");
}
public static void main(String[] args){
MyTest5 t = new MyTest6();
t.f(); //向上转型调用的方法，如子类有重写方法，则调用子类的
// t.g(); //向上转型会丢失方法
}
}

class MyTest6 extends MyTest5{
public void f(){
System.out.println("This is the class MyTest6");
}
public void g(){
System.out.println("The mothod g");
}
}

（2）再论组合与继承

在实际中，继承技术其实不太常用的。因此，尽管在教授OOP的过程中我们多次强调继承，但并不意味可以随便滥用，相反，使用时应谨慎使用。

应该是使用组合还是继承这里有一个清晰的判断：

是否需要从新类向基类进行向上转型。如果必须向上转型，则继承是必须的，但如果不需要，则应当好好考虑自己是否需要继承。

8、final关键字

先看下面一个实例：

public class MyTest7 {
private static Random rand = new Random(47);
private String id;
public MyTest7(String id){
this.id = id;
}
private final int valueOne = 9;
private static final int VALUE_TWO = 99;
public static final int VALUE_THREE = 39;
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);
private final int[] a = {1,2,3,4,5,6};

@Override
public String toString(){
return id + ":"+"i4=" + i4 + ",INT_5" + INT_5;
}

public static void main(String[] args){
MyTest7 t1 = new MyTest7("t1");
// t1.valueOne++; //不能改变常量的值
t1.v2.i++;
t1.v1 = new Value(9);
for(int i =0;i<t1.a.length;i++){
t1.a[i]++;
}
// t1.v2 = new Value(0); //用final修饰的引用对象不能指向新的对象
// t1.VAL_3 = new Value(1);
// t1.a = new int[3];

System.out.println(t1);
System.out.println("Creating new MyTest7");
MyTest7 t2 = new MyTest7("t2");
System.out.println(t1);
System.out.println(t2);
}
}