《Thinking in Java》Seven 复用类-优快云博客

2019独角兽企业重金招聘Python工程师标准>>>

组合：在一个新类中创建另一个已有类的对象。

继承：是所有OOP语言不可缺少的组成部分，会自动得到基类中所有的域和方法，extends

package sixth;

class Art{
 Art(){System.out.println("JiLei1");}
}
class Drawing extends Art{
 Drawing(){
  System.out.println("extends JiLei 2");
 }
}
public class ExtendsD extends Drawing{
 
 public static void main(String[] args){
  new ExtendsD();
 }
}/*JiLei1
extends JiLei 2*/

代理

代理是组合和继承的中庸之道

package sixth;

//代理是组合和继承的中庸之道

class Cleaner{
 private String s = "Cleaner";
 public void append(String a){System.out.println(s += a);}
 public void apply(){append("apply()");}
 public void scrub(){append("scrub()");}
 public String toString(){return s;}
}

//将一个成员对象置于所要构建的类中private Cleaner cle = new Cleaner();像组合

/*同时在新类中暴露该对象的所有方法public void append(String a){cle.append(a);}
//public void apply(){cle.apply();}
//public void scrub(){cle.scrub();}
//public String toString(){System.out.println(s);return s;}像继承*/

public class DaiLi {
 private String s = "DaiLi";
 private Cleaner cle = new Cleaner();
 public void append(String a){cle.append(a);}
 public void apply(){cle.apply();}
 public void scrub(){cle.scrub();}
 public String toString(){System.out.println(s);return s;}
 
 public static void main(String[] args){
  DaiLi dL = new DaiLi();
  dL.append("12");
  dL.apply();
  dL.scrub();
  dL.toString();
 }

}/*使用代理

Outputs:
Cleaner12
Cleaner12apply()
Cleaner12apply()scrub()
DaiLi*/

初始化顺序

 package sixth;
class Insect {
    private static int si = numOfLegs("Static si Insect");
    protected int j;
    private int i = 0;
    public Insect() {
    
        // j并未初始化
      
        System.out.println("Insect Constructor: i = " + i + " j = " + j);
        j = 10;
    }
    protected static int numOfLegs(String s) {
        System.out.println(s);
        return 4;
    }
}
class Beetle extends Insect {
    private static int si = numOfLegs("Static si Beetle");
    private int i = numOfLegs("Beetle");
  
    // 并未显示调用Insect的构造函数
  
    public Beetle() {
        System.out.println("Beetle Constructor: i = " + i + " si = " + si);
    }
}
public class Cockroach extends Beetle {
    private static int si = numOfLegs("Static si Cockroach");
    private int i = numOfLegs("Cockroach");
  
    // 并未显示调用Insect的构造函数
   
    public Cockroach() {
        System.out.println("Cockroach Constructor: i = " + i + " si = " + si);
    }
    public static void main(String[] args) {
        System.out.println("Cockroach Construct");
   
       Cockroach b = new Cockroach(); // 构造引起静态变量初始化
    
        System.out.println(Cockroach.si); // 调用静态变量
    }
}
/*
 * Static si Insect //根基类的static先被加载
Static si Beetle    //基类的static被加载
Static si Cockroach //导出类 static加载
Cockroach Construct //进入main()
Insect Constructor: i = 0 j = 0//根基类的构造器加载，对象中的基本类型被初始化 j被初始化为0，对象的引用被初始化为null 
Beetle        //基类方法
Beetle Constructor: i = 4 si = 4 //导出类构造器
Cockroach
Cockroach Constructor: i = 4 si = 4
4*/

final和private

package sixth;
class WithFinals{
 private final void f(){
  System.out.println("WithFinals f()");
 
  }//与不加final是一样的，private方法隐含是final的
 
 protected void g(){
  System.out.println("WithFinals g()");
  }
}
final class OverridePrivate extends WithFinals{

 //@Override private方法无法覆盖

 private void f(){
  System.out.println("OverridePrivate f()");
 }
 @Override
 protected void g(){
  System.out.println("OverridePrivate g()");
  }
}

//final类不能被继承

/*class OverridePrivate2 extends OverridePrivate{
 //@Override
 public final void f(){
  System.out.println("OverridePrivate2 f()");
 }
 @Override
 public void g(){
  System.out.println("OverridePrivate2 g()");
 }
}*/
public class FinalMethod {
 public static void main(String[] args){
  //OverridePrivate2 op2 = new OverridePrivate2();
  //op2.f();
  //op2.g();
  
  //OverridePrivate op = op2;
 
  //op.f(); 无法调用
 
  //op.g();
  
  WithFinals wf = new WithFinals();
  
  wf.g();
 
  //wf.f(); 无法调用the method f() from WithFinals is not visible
 
  //private方法看成他所属的类的组织结构的原因而存在 无其他意义
 
 }
}

static final

一个既是static又是final的域占据一段不能改变的存储空间，定义为static强调只有一份，定义为final说明是一个常量。

向上转型

导出类是基类的一个超集，可能含有比基类更多的方法，但至少具备基类的方法，在向上转型过程中可能会丢失方法。

package sixth;
class Amphibian{
 public void say(Amphibian a){
  System.out.println(a + " say hi");
 }
}
class Frog extends Amphibian{
 
}
public class XiangShangZhuanXing {
 
 public static void say(Amphibian a){
  System.out.println(a + " say hello");
 }
 public static void main(String[] args){
  Frog frog = new Frog();
  frog.say(frog);
  say(frog);
 }
}
/*sixth.Frog@19e0bfd say hi  基类的方法
sixth.Frog@19e0bfd say hello*/

转载于:https://my.oschina.net/doudoulee/blog/651992