文档章节

[笔记]改善Java程序的151个建议---第三章 类,对象,方法

jimyao
 jimyao
发布于 2016/01/29 14:47
字数 3176
阅读 4
收藏 0

第三章 类,对象,方法
建议31:在接口中不要存在实现代码
接口是一种契约,框架协议,表明它的实现类都是同一种类型,或者具备相似特征的一个集合体。

建议32:静态变量一定要先声明后赋值
静态变量在类初始化时候首先被加载。
public static int i = 1;
static{
     i = 100;
}

建议33:不要覆写静态方法
@Override针对非静态方法
一个实例对象有2个类型,表面类型(Apparent Type),实际类型(Actual Type)。
表面类型是声明时的类型
实际类型是对象产生时候的类型。
非静态方法是根据对象的实际类型执行的。
静态方法特殊,不依赖实例对象,通过类名访问,也可以通过对象访问。对象访问的话,JVM会通过对象的表面类型找到静态方法入口。

在子类中构建与父类相同的静态方法,这种行为叫“隐藏”。

通过实例对象访问静态方法或者属性不是好习惯。

建议34:构造函数尽量简化
构造函数初始化顺序:
子类实例化,首先初始化父类(初始化不是生产父类对象)初始化父类的变量,调用父类的构造函数,然后才会初始化子类的变量,调用子类的构造函数。最后才生产一个实例对象。
构造函数,用于初始化变量,声明实例的上下文。

建议35:避免在构造函数中初始化其他类
不要在构造函数中声明初始化其他类,是良好习惯。
否则会造成StackOverflowError

建议36:使用构造代码块精炼程序
代码块:用大括号把多行代码封装在一起,形成一个独立的数据体,实现特定算法的代码集合。
Java中有4种类型代码块:
(1)普通代码块
方法后面用{},必须通过方法名调用。
(2)静态代码块
static{},用于静态变量初始化,对象创建前的环境初始化。
(3)同步代码块
synchronized{},表示同一时间只能一个线程进入该代码块。一种线程保护机制。
(4)构造代码块
类中没有任何前缀、后缀,用{}括起来。

编译器如果处理构造代码块?编译器会把构造代码块插入到每个构造函数的最前端。构造代码块会在每个构造函数内首先执行。

应用场景:在每个构造函数中运行,在构造函数中首先运行。
初始化实例变量
初始化实例环境

public class Client{
     {
          //构造代码块
          System.out.println("构造代码块");
     }
    
     Client(){
          System.out.println("无参构造函数");
     }
    
     Client(String str){
          System.out.println("有参构造函数");
     }
}

建议37:构造代码块会想你所想
统计一个类实例的数量
构造函数调用自身其他的构造函数(this关键字),则不插入构造代码块。
class Base{
     //对象计数器
     private static int numOfObjects = 0;
    
     {
          //构造代码块
          numOfObject++;
     }
    
     public Base(){}
    
     //有参调用无参构造
     public Base(String str) {
          this();
     }
    
     //有参不调用其它构造
     public Base(int i){
     }
    
     public static int getNumOfObjects(){
          return numOfObjects;
     }
}

public class Client{
     public static void main(String[] args){
          new Base();
          new Base("");
          new Base(0);
          System.out.println(Base.getNumOfObjects());
     }
}

count = 3


建议38:使用静态内部类提高封装性
Java中嵌套类(Nested Class)分为两种:静态内部类(Static Nested Class) 和内部类(Inner Class)。
静态内部类2个优点:加强了类的封装性和提高了代码的可读性。形似内部,神似外部。编译后类文件名也包含外部类,外部类$内部类。他们之间是强关联关系。
静态内部类和普通类的区别:
(1)静态内部类不持有外部类的引用。普通内部类,可以直接访问外部类的属性和方法。静态内部类,只可以访问外部类的静态方法和静态属性,其他不行。
(2)静态内部类不依赖外部类
普通内部类和外部类之间是依赖关系,内部类不能脱离外部类实例,同生共死不能独立存在。静态外部类可以独立存在,即是外部类消亡,其还可以存在。
(3)普通内部内不能声明static变量和方法
普通内部内不能声明static变量和方法,常量(final static)还是可以的,静态内部类没有任何限制。
public class Person{
     private String name;
     private Home home;
    
     Person(String name){
          this.name = name;
     }
    
     public static class Home{
          private String address;
          private String tel;
         
          Home(String address, String tel) {
               this.address =addresss;
               this.tel = tel;
          }
     }
}

建议39:使用匿名类的构造函数
List l1 = new ArrayList();
List l2 = new ArrayList(){};
List l3 = new ArrayList(){{}};
List l4 = new ArrayList(){{}{}{}{}{}{}};//也可以是多个
l2是匿名类的声明和赋值,定义了一个继承于ArrayList的匿名类。代码类似于:
class Sub extends ArrayList{
}
List l2 = new Sub();

l3是匿名类的声明和赋值。代码类似于:
class Sub extends ArrayList{
     {
          //初始化块,充当构造函数功能
     }
}
List l3 = new Sub();

建议40:匿名类的构造函数很特殊
一般类(显式名字的类)所有构造函数默认都是调用父类的无参构造。
匿名类构造函数处理机制,匿名类没有名字,只能有构造代码块代替,在其初始化的时候直接调用父类同参数构造,然后再调用自己的构造函数。
enum Ops{ADD, SUB};

class Calculator{
     private int i,j,result;
    
     public Calculator(){};
    
     public Calculator(int i, intj){
          this.i= i;
          this.j = j;
     }
    
     //设置运算符号
     protected  void setOperator(Ops ops){
          result = ops.equals(Ops.ASS) ? i + j : i -  j;
     }
    
     //获得运算结果
     public int getResult(){
          return this.result;
     }
}

public static void main(String[] args){
     Calculator cl = new Calculator(1,2){
          setOperator(Ops.ADD);
     }
     System.out.println(cl.getResult());
}

//上面匿名函数相当于
class Add extends Calculator{
     {
          setOperator(Ops.ADD);
     }
     //覆写父类的构造方法
     public Add(int i, int j){
          super(i, j);
     }
}

建议41:让多重继承成为现实
一个类可以多个接口,但不能继承多个类。有时候确实需要继承多个类,Java提供内部类曲折解决此问题。
interface Father{
     public int strong();
}
interface Mother{
     public int kind();
}

class FatherImpl implements Father{
     public int strong(){
          return 8;
     }
}

class MotherImpl implements Mother{
     public int kind(){
          return 8;
     }
}

class Son extends FatherImpl implements Mother{
     @Override
     public int strong(){
          return super.strong() + 1;
     }
    
     @Override
     public int kind(){
          return new MotherSpecial.kind();
     }
     //内部类
     private class MotherSpecial extends MotherImpl{
          public int kind(){
               return super.kind() - 1;
          }
     }
}


//女儿继承了母亲的kind,同时覆写了父类的strong,这里建立了一个匿名内部类来覆写父类的方法。
class Daughter extends MotherImpl implements Father{
     @Override
     public int strong(){
          return new FatherImpl(){
               @Override
               public int strong(){
                    return super.strong() - 2;
               }
          }.strong();
     }
}

建议42: 让工具类不可实例化
Java工具类的方法和属性都是静态的。由于不希望被初始化,于是设置构造函数为private权限,表示除了类本身外,谁都不能产生一个实例。工具类不要继承。
public class UtilsClass{
     private UtilsClass(){
          throw new Error("不要实例化我");
     }
}

建议43:避免对象的浅拷贝
一个类实现了Cloneable接口表示具备了被拷贝能力,覆写了clone()方法完全具备拷贝能力。
浅拷贝,对象属性拷贝不彻底的问题。

public class Person implements Cloneable{

        //姓名

        private String name ;

        //父亲

        private Person father ;

       

       Person(String name){

               this.name = name ;

       }

       

       Person(String name, Person parent){

               this.name = name ;

               this.father = parent ;

       }


        public String getName() {

               return name ;

       }


        public void setName(String name) {

               this.name = name ;

       }


       

        public Person getFather() {

               return father ;

       }


        public void setFather(Person father) {

               this.father = father ;

       }


        @Override

        public Person clone(){

              Person p = null;

               try {

                      p = (Person) super.clone();

                      p.setFather( new Person(p .getFather().getName()));

              } catch (CloneNotSupportedException e ) {

                      // TODO Auto-generated catch block

                      e.printStackTrace();

              }

               return p ;

              

       }

       

}


public class Client {


        public static void main(String[] args) {

               //定义父亲

              Person f = new Person("父亲" );

               //定义大儿子

              Person s1 = new Person("大儿子" , f );

               //小儿子

              Person s2 = s1 .clone();

              s2.setName("小儿子");

              

               //认干爹

               s1.getFather().setName( "干爹");

              System. out.println(s1 .getName() + " 父亲是: " + s1.getFather().getName());

              System. out.println(s2 .getName() + " 父亲是: " + s2.getFather().getName());

              

       }

}


建议44:推荐使用序列化实现对象拷贝
序列化实现对象拷贝比每一个类都写clone更好的办法
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class CloneUtils {
     //拷贝一个对象
     @SuppressWarnings("unchecked")
     public static <T extends Serializable> T clone(T obj) {
          //拷贝产生的对象
            T cloneObj = null;
          try {
                    //读取对象字节顺序
               ByteArrayOutputStream baos = new ByteArrayOutputStream();
               ObjectOutputStream oos = new ObjectOutputStream(baos);
               oos.writeObject(obj);
               oos.close();
               //分配内存空间,写入原始对象,生成新对象
               ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
               ObjectInputStream ois = new ObjectInputStream(bais);
                  //返回新对象并作类型转换
               cloneObj = (T)ois.readObject();
               ois.close();
          }catch(ClassNotFoundException | IOException e) {
               e.printStackTrace();
          }
          return cloneObj;
     }
}

上面那个Person类implements Serializable加上SerialVersionUID就可以实现深拷贝

注意两点:
(1)对象内部的属性都是可以序列化的,如内部属性不可序列化,会抛出异常。
(2)注意方法和属性的特殊修饰符
final,static的问题,transient变量的问题。
更简便的方法是,用Apache commons工具包中的SerializationUtils类

建议45:覆写equals方法时候不要识别不出自己
在写一个JavaBean时,经常会覆写equals方法。根据业务规则判断两个对象是否相等。
equals方法的自反性原则:对于任何非空引用x,   x.equals(x)应该返回true。
不要在p.getName()后面在加上.trim()。

例子见46

建议46:equals应该考虑null值情景
equals对称性原则:对于任何引用x和y的情景,如果x.equals(y)返回true,那么y.equals(x)也应该返回true。

//Object Equals
public class PersonEqual {
     String name;
   
     PersonEqual(String _name){
          this.name = _name;
     }
   
   
     public String getName() {
          return name;
     }


     public void setName(String name) {
          this.name = name;
     }


     public boolean equals(Object obj){
          if(obj != null && obj.getClass() == this.getClass()){
               PersonEqual p = (PersonEqual)obj;
               if(p.getName() == null || this.name == null)
                    return false;
               else
                    return this.name.equalsIgnoreCase(p.getName());
          }
          return false;
     }
}


import java.util.ArrayList;
import java.util.List;


public class Client {
     public static void main(String[] args) {
          PersonEqual pe1 = new PersonEqual("yao");
          PersonEqual pe2 = new PersonEqual("yao ");
        
          List<PersonEqual> list = new ArrayList<>();
          list.add(pe1);
          list.add(pe2);
        
          System.out.println(list.contains(pe1));
          System.out.println(list.contains(pe2));
     }
}

//建议47:在equals中使用getClass进行类型判断
equals传递性原则:对于实例对象x,y,z。如果,x.equals(y)返回true,y.equals(z)返回true,那么x.equals(z)也应该返回true。
//不是同一个类的2个值不能比较相等
//覆写equals时候,用getClass()代替instanceof判断
public class Emp extends PersonEqual {

     private int id;
     Emp(String _name, int _id) {
          super(_name);
          this.id=_id;
          // TODO Auto-generated constructor stub
     }
     public int getId() {
          return id;
     }
     public void setId(int id) {
          this.id = id;
     }

     public boolean equals(Object obj){
          if(obj != null && obj.getClass() == this.getClass()) {
               Emp emp = (Emp)obj;
               return super.equals(obj) && emp.getId() == this.id;
          }
          return false;
     }
}

import java.util.ArrayList;
import java.util.List;


public class Client {
     public static void main(String[] args) {
          Emp e1 = new Emp("yao", 100);
          Emp e2 = new Emp("yao", 1001);
          PersonEqual pe = new PersonEqual("yao");
          System.out.println(pe.equals(e1));
          System.out.println(pe.equals(e2));

     }
}


建议48:覆写equals方法必须覆写hashCode方法
List中Person类的equals覆写了,不再判断两个类的地址是否相等,而是根据equals中的name判断两个对象是否相等。
HashMap的底层处理机制是数组的方式保存MAP条目(Map Entry),关键是数组下标的处理机制。根据传入元素hashCode方法的返回值决定其数组的下标。
如果,该数组位置上已经有了Map条目,并且与传入的键值相等则不处理。
如果,不想等则覆盖;如果数组位置没有条目,则插入,并加入到Map条目的链表中。
检查键是否存在也是根据哈希码定位的,然后遍历查找键值。
hashCode方法的返回值是什么?是一个对象的哈希码。由Object类的本地方法生成,确保每一个对象有一个哈希码。
重写Person类的hashCode方法。
//Person HashCode
public class PersonHashCode {
     String name;
   
     PersonEqual(String _name){
          this.name = _name;
     }
   
   
     public String getName() {
          return name;
     }


     public void setName(String name) {
          this.name = name;
     }


     public boolean equals(Object obj){
          if(obj != null && obj.getClass() == this.getClass()){
               PersonEqual p = (PersonEqual)obj;
               if(p.getName() == null || this.name == null)
                    return false;
               else
                    return this.name.equalsIgnoreCase(p.getName());
          }
          return false;
     }
    
     @Override
     public int hashCode(){
          return new HashCodeBuilder().append(this.getName).toHashCode();
     }
}

public static void main(String[] args){
     //Person类作为Map的Key
     Map<Person, Object> map = new HashMap<>{
          {
               put(new Person("张三"),new Object());
          }
     };
    
     //Person类的实例作为List的元素
     List<Person> list = new ArrayList<>{
          {
               add(new Person("张三"));
          }
         
     };
    
     boolean b1 = list.contains(new Persion("张三"));
     boolean b2 = map.containsKey(new Person("张三"));
}

建议49:推荐覆写toString方法
Java本身提供的toString方法不友好。
ToStringBuilder    //代替Javabean中的toString()方法

建议50:使用package-info类为包服务
特殊的类:package-info
专门为包服务。描述和记录包的信息。
不能随便被创建,服务的对象特殊,此类不能有实现代码。

作用:
(1)声明友好类和包内访问常量
//这里是类包,声明一个包使用的公共类
class PkgClass{
     public void test(){}
}
//包常量,只允许包内访问
class PkgConst{
     static final String  PACKAGE_CONST = "ABC";
}
(2)为包上提供注解便利
写一个注解标注,放到package-info文件中。
(3)提供包的整体注释说明

建议51:不要主动进行垃圾回收


© 著作权归作者所有

共有 人打赏支持
jimyao
粉丝 17
博文 66
码字总数 27856
作品 0
朝阳
私信 提问
《编写高质量代码 改善Java程序的151个建议》读书笔记

第7章 泛型和反射 建议94 不能初始化泛型参数的数组 Java的泛型在编译期有效,在运行期被删除,所有的泛型参数类型在编译后都会被擦出掉 Java泛型类和普通类在编译后都指向同一字节码 第8...

OSC_fly
08/23
0
0
java 私塾随堂笔记——Hibernate(上)

java 私塾随堂笔记——Hibernate(上) 第一章 Hibernate介绍 一.是什么: Hibernate是轻量级的ORM框架。 1.ORM(ORMapping) Object——Mapping——→Relation DB Object←——JDBC———Rel...

luodis
2011/03/21
438
0
读《深入理解Java虚拟机》- 笔记08

《深入理解Java虚拟机:JVM高级特性与最佳实践》第2版 第10章 早期(编译期)优化 59. 语法糖 在计算机语言中添加某种语法,对语言的功能没有影响,但是方便开发人员使用。 泛型是一种语法糖...

阿历Ali
08/18
0
0
读书笔记之《Java并发编程的艺术》-并发编程基础

读书笔记部分内容来源书出版书,版权归本书作者,如有错误,请指正。 欢迎star、fork,读书笔记系列会同步更新 git https://github.com/xuminwlt/j360-jdk module j360-jdk-thread/me.j360....

Hi徐敏
2015/11/11
0
8
Android--面试中遇到的问题总结(三)

《Android 开发工程师面试指南 LearningNotes 》,作者是陶程,由梁观全贡献部分。大家可以去知乎关注这两位用心的少年。这份指南包含了大部分Android开发的基础、进阶知识,不仅可以帮助准备...

sealin
2017/02/22
0
0

没有更多内容

加载失败,请刷新页面

加载更多

TensorFlow的基础概念02

TensorFlow的计算流图 import osos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'#TensorFlow的计算模型,数据流图'''TensorFlow = Tensor + FlowTensor 张量 数据结构:多维数组Flo...

怪咖先生forever
10分钟前
1
0
大数据技术的发展趋势

大数据领域已经涌现出了大量新的技术,它们成为大数据采集、存储、处理和呈现的有力武器。这些技术下一步将如何发展?它们之中哪些技术将广为流行?又会诞生哪些新的技术? 技术趋向多样化,...

董黎明
26分钟前
7
0
藏在正则表达式里的陷阱

前几天线上一个项目监控信息突然报告异常,上到机器上后查看相关资源的使用情况,发现 CPU 利用率将近 100%。通过 Java 自带的线程 Dump 工具,我们导出了出问题的堆栈信息。 我们可以看到所...

前端小攻略
28分钟前
3
0
关联更新,关联查询

关联更新 update A,B SET A.c1=B.c1,A.c2=B.c2 where A.id=B.id and ... update A inner join on A.id=B.id set A.c1=B.c1,A.c2=B.c2 where... 关联查询 交叉连接(cross join),内连接(inner ......

关元
31分钟前
3
0
django的环境搭建及启用

Pycharm社区版不像商业版那样可以直接创建django工程,需要通过一下步骤创建: 新建一个用于Django开发的虚拟环境 打开命令窗口 新建虚拟环境: conda create -n env_name python=3.6 查看系...

davidwbnu
32分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部