首页 > 编程语言> 文章详细

Thinking In Java 4th Chap7 复用类

2019-09-15 13:02:48 阅读：258 来源： 互联网

标签：Thinking public Chap7 继承 4th 对象基类方法 final

复用代码的两种方法：组合和继承

组合方法：（新类中产生现有类的对象）

　　没什么好说的，就是调用别类的对象而已

　　值得一提的是一个特殊方法：toString（）当需要一个String却只有对象时能够自动调用此方法（每个类只需写一个toString方法）

　　　　例如：class Myclass{

　　　　　　　　/*..............*/

　　　　　　　　private String s;

　　　　　　　　public String toString(){

　　　　　　　　　　return s;} }

　　对象引用的初始化方法：1.定义对象之时即初始化　　2.在类的构造器中初始化　　3.在使用对象之前才初始化　　4.实例初始化

 1 class Soap {
 2     public Soap() {
 3         System.out.println("Soap");
 4     }
 5 
 6     @Override
 7     public String toString() {
 8         return "Constructed";
 9     }
10 }
11 
12 public class TestInit {
13     private String s1 = "Happy"; // 定义初始化
14     private Soap s2;
15     private String s3, s4;
16 
17     // 实例初始化
18     {
19         s2 = new Soap();
20     }
21 
22     public TestInit() {
23         s3 = "Good"; // 构造器初始化
24     }
25 
26     @Override
27     public String toString() {
28         s4 = "Girl"; // 惰性初始化
29         return "TestInit{" + "s1='" + s1 + ", s2=" + s2 +
30                 ", s3='" + s3 + ", s4='" + s4 + '}';
31     }
32 
33     public static void main(String[] args) {
34         TestInit ti = new TestInit();
35         System.out.println(ti);
36     }
37 }
38 /*
39     Output:
40     Soap
41     TestInit{s1='Happy, s2=Constructed, s3='Good, s4='Girl}
42  */

继承方法：（按照现有类的类型创建新类）

　　除非指明要继承的类，否则隐式地从根类Object进行继承

　　例如：public class Detergent extends Cleaner{/*...................*/}类Detergent继承自类Cleaner，获得Cleaner的全部域和方法

　　通常为了继承，将所有基类的数据成员定义为private，将所有方法定义为public（或protected）

　　想要调用基类的方法，使用super关键字：super.funcFromBase();

　　调用继承类对象的同时不仅调用了自己的构造器，也调用了基类的构造器（而且是在调用自己的构造器之前）

　　　　如果基类的构造器带有参数，调用基类的构造器需要使用super：

　　　　例如：class Base{

　　　　　　　　Base(int i){/*...............*/} }

　　　　　　　class Myclass extends Base{

　　　　　　　　Myclass(int i){

　　　　　　　　super(i);

　　　　　　　　/*...................*/} }

介乎组合和继承之间还存在一种方法：代理（在自己的类中建立别类的对象，在自己的方法中调用对象的方法）

　　例如：//在类的域中

　　　　　Baseclass bc = new Baseclass();

　　　　　void Myfunc(){

　　　　　　bc.Myfunc();}

　　　　　/*.............*/

　　使用代理的好处是我们可以控制使用“基类”的部分成员而不用全盘“拿来主义”

其中一种清理方式是try-finally语句组合（即使需要手动清理，也不要使用finalize（））

　　try{

　　//需要被特殊处理的代码}

　　finally{

　　//不管怎样，只要try语句块内代码执行完成就会调用的代码}

不同于c++：继承类重新定义基类的某个多次重载的方法，不会屏蔽该方法在基类中的任何一个版本

@override注解：想要覆写某个方法却不小心重载了该方法时，编译器会生成一条错误信息

覆写：方法名和参数列表都完全一致　　重载：方法名一致但是参数列表不同

如果是“是一个”的关系，应当使用继承（实际上慎用继承是明智的选择，如果不是必须向上转型，那么继承则不是必要的）；

如果是“有一个”的关系，应当使用组合（组合在一般情况下在新类中应使调用对象域为private）

向上转型：

　　其中一例是在继承类中的对象作为参数可以使用基类中的方法（虽然基类中的方法的参数并非继承类中的对象类型，却可以使用）

　　例如：class Base{

　　　　　　play(Base bs){/*.................*/} }

　　　　　public class Son extends Base{

　　　　　　Son sn=new Son();

　　　　　　Base.play(sn);}这里将子类引用转换为基类引用

final关键字：(类比c++中的const关键字）

　　编译期常量，这类常量必须是基本数据类型而且以final修饰

　　对象引用可以是常量，也就是说永远只指向同一对象（但是指向的对象的值是可以改变的，Java并不提供任何使对象恒定不变的途径）

　　同时以static和final修饰的只占有一份不变空间的常量，其名称全部大写并以_分隔单词

　　使用final参数意味着无法在方法中改变参数引用所指向的对象，也无法改变基本数据的值：

　　　　void func（final Myclass mc）{

　　　　　　//! mc=new Myclass(); mc因为是final修饰的，所以无权再指向新的对象

　　　　　　/*...............*/}

　　final方法：将方法锁定，防止继承类修改其含义

　　　　类中所有的private方法都隐式的认为是final，如果在继承类中写一个同名的方法（并无向上引用的接口），仅仅是同名而已（与基类方法并无关联）

　　　　只有方法是基类的接口的一部分（即能够将一个对象向上引用为基类的基本类型并调用相同方法），才能体现“覆盖”效应（无private或final的保护）

　　final类：如果将类整体定义为final（例如：final class Myclass{/*..........*/}）,则断绝了继承该类的途径，而且类中所有的方法都隐式指定为final

所有static对象和代码段按定义类时的书写顺序而依次初始化

类是在其任何static成员被访问时加载的（构造器是隐式的static成员）

调用一个继承类的初始化顺序：基类->(可能存在的其他基类）->继承类

标签：Thinking,public,Chap7,继承,4th,对象,基类,方法,final
来源： https://www.cnblogs.com/hfut-freshguy/p/11521831.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Thinking In Java 4th Chap7 复用类