学习Java类必须知道的几点
来源:互联网 发布:sql向表中更改字段 编辑:程序博客网 时间:2024/04/30 14:21
1、类的加载执行顺序
看一下如下的例子:
[java] view plaincopyprint?
class ParentClass {
public static int a=2;
public int b=3;
{
System.out.println("this is anonymity b="+b);
}
static {
a=4;
System.out.println("this is static and a="+a);
}
public ParentClass() {
System.out.println("this is parent gozao");
this.s();
}
public void s() {
System.out.println("this is parent");
}
}
public class Son extends ParentClass {
public Son(){
System.out.println("this is son gozao");
}
public static void main(String[] args) {
ParentClass d = new Son();
d.s();
}
public void s() {
//super.s();
System.out.println("this is son");
}
}
运行结果如下:
[java] view plaincopyprint?
this is static and a=4
this is anonymity
this is parent gozao
this is son
this is son gozao
this is son
可以看出类内的加载顺序为:
(1)初始化变量。对于静态变量肯定要首先进行初始化,因为后面的方法可能会使用这个变量,或者构造函数中也可能用到。而对于非静态变量而言,由于匿名块内、非静态方法和构造函数都可以进行操作(不仅仅是初始化),所以要提前进行加载和赋默认值。
(2)初始化静态代码块,多个静态代码块按顺序加载,这里需要注意:在这个顺序不难是类内书写的顺序,也是类加载的顺序,也就是说如果子类也有静态代码块,则子类的也加载。由于静态代码块可能会负责变量的初始化,或者是对象等的初始化,这样在构造函数或者方法中就变得可用了。而顺序加载多半是由于Java是按顺序执行代码的原因。
(3)匿名代码块,这个要后初始化于静态代码块,因为其依然属于实例对象,而不属于类。在这里可以对非静态成员变量进行初始化工作。
(4)构造函数 这里需要解释一下,为什么初始化子类必先初始化父类,由于子类可能会继承父类的属性或方法,所以肯定要先初始化父类了,而初始化父类则必须要调用父类的构造函数。
至于方法不用考虑,因为方法不用初始化,所以无论是静态还是不静态,和这个没有关系。
其实如上的代码还能说明一些问题,可以看到,在父类中通过this.s()调用的是子类的方法,子类的s()方法覆盖了父类的方法后,无论在哪里调用,都是调用子类的方法。
2、不可变类
不可变类是指当创建了这个类的实例后,就不允许修改它的属性值。在JDK的基本类库中,所有基本类型的包装类,如Integer、Long等都是不可变类,除此之外还有java.lang.String也是不可变类。不可变类的实例一但创建,其内在成员变量的值就不能被修改。创建一个不可变类需要如下条件:
1. 对于一般成员都是private,还可以使用public static final 来定义一个全局的常量。
2. 不提供对成员的修改方法,例如:setXXX()
3. 确保所有的方法不会被重载。手段有两种:使用final Class(强不可变类),或者将所有的类方法加上final关键字(弱不可变类)。
4. 如果某一个类成员不是原始变量(primitive)或者不可变类,必须通过在成员初始化或者get方法时通过深度clone方法,来确保类的不可变。
其它的都好理解,下面来着重解释一下第4条。举个例子:
[cpp] view plaincopyprint?
public final class MyImmutableWrong { // 使用final关键字声明为强不可变类
private final int[] myArray;
public MyImmutableWrong(int[] anArray) {
this.myArray = anArray; // wrong
}
public String toString() {
StringBuffer sb = new StringBuffer("Numbers are: ");
for (int i = 0; i < myArray.length; i++) {
sb.append(myArray[i] + " ");
}
return sb.toString();
}
}
由于int[] anArray是一个数组,属于引用类型。这样当再次去操作外部的一个引用时,其指向的共同内容,也就是数组的值。
[java] view plaincopyprint?
public class dd {
public static void main(String[] args) {
int array[]={1,2,3,4};
MyImmutableWrong service=new MyImmutableWrong(array);
array[2]=99;
System.out.println(service.toString());
}
}
查看控制台的输出内容:Numbers are: 1 2 99 4
可以看到,不可变类中的数组内容发生了改变。究其原因就是 - 关键字final仅对其直接指向的对象有用,并且final引用可以指向带有非final域的对象。
为了避免这个问题,必须对数组进行深度克隆。也就是专门再为不可变类中的数组开避一份内存空间,然后将参数的值赋值过去。正确的写法如下:
[java] view plaincopyprint?
public final class MyImmutableCorrect {
private final int[] myArray;
public MyImmutableCorrect(int[] anArray) {
this.myArray = anArray.clone();
}
public String toString() {
StringBuffer sb = new StringBuffer("Numbers are: ");
for (int i = 0; i < myArray.length; i++) {
sb.append(myArray[i] + " ");
}
return sb.toString();
}
}
测试后发现:Numbers are: 1 2 3 4
不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。
3、静态内部类
内部类就是在一个类的内部定义的类,内部类中不能定义静态成员(静态成员不是对象的特性,只是为了找一个容身之处,所以需要放到一个类中而已,把“全局变量”放在内部类中就是毫无意义的事情,所以被禁止),内部类可以直接访问外部类中的成员变量,即使这个成员变量是由private来修饰的。
同样拿不可变类来举一个例子。假如这个不可变类中有许多的private final属性需要初始化,这时候看起来就不太方便。可能有人会采用工厂方法来解决,但有时候也可以使用静态内部类来解决这一问题。如下:
[java] view plaincopyprint?
public class Author {
private final String name;
public String getName() {
return name;
}
public Author(String name_) {
name = name_;
}
@Override
public String toString() {
return "Author [name=" + name + "]";
}
}
[java] view plaincopyprint?
public final class Update { // 强不可变类
private final Author author; // 作者,是个引用变量
private final String updateText; // 更新内容
private final long createTime; // 更新时间
// 私有构造函数,防止外部实例化
private Update(Builder b_) {
author = b_.author;
updateText = b_.updateText;
createTime = b_.createTime;
}
// 构建器
public static class Builder {
private long createTime;
private Author author;
private String updateText;
public Builder author(Author author_) {
author = author_;
return this;
}
public Builder updateText(String updateText_) {
updateText = updateText_;
return this;
}
public Builder createTime(long createTime_) {
createTime = createTime_;
return this;
}
public Update build() {// 更新外部类的值
return new Update(this);
}
}
public Author getAuthor() {
return author;
}
public String getUpdateText() {
return updateText;
}
@Override
public String toString() {
return "Update [author=" + author + ", updateText=" + updateText
+ ", createTime=" + createTime + "]";
}
}
可以看到,静态内部类有与外部类同样的成员变量,但是静态内部类中的成员变量却是可以修改的。
来测试一下:
[java] view plaincopyprint?
public class Test {
public static void main(String[] args) {
final Update first = getUpdate("abc");// 获取不可变类的实例
System.out.println(first.toString());
}
private static Update getUpdate(String s) {
Update.Builder b = new Update.Builder();
b.updateText(s).author(new Author("mazhi"));
return b.build();// 初始化不可变类并返回实例
}
}
运行后的结果如下:
Update [author=Author [name=mazhi], updateText=abc, createTime=0]
在方法外部定义的内部类可以加上static关键字、可以定义成public、protected、默认的、private等多种类型,而普通类只能定义成public和默认的这两种类型。在外面引用静态内部类的名称为"外部类名.内部类名"。不需要创建外部类的实例对象,就可以直接创建静态内部类。例如:
[java] view plaincopyprint?
Update.Builder b = new Update.Builder(); // 获取静态内部类的实例对象
由于不依赖于外部类的实例对象,所以能访问外部类的非static成员变量。
想了解更多的内部类,可以查阅其它资料。
- 学习Java类必须知道的几点
- Java 7之基础 - 学习Java类必须知道的几点
- 机器学习你必须知道的几点知识
- 谈学习:合格的编程自学者必须知道的几点
- DEDECMS安装你必须知道的几点
- 高考填报志愿必须知道的几点知识
- 使用C风格字符串你必须知道的几点
- Android自定义View,你必须知道的几点
- Android自定义View,你必须知道的几点 入门
- 作为程序员你必须知道的几点
- Android自定义View,你必须知道的几点
- php文件上传你必须知道的几点
- Android自定义View,你必须知道的几点
- 关于dhcp服务你必须知道的几点
- 学习java必须知道的几个东西
- 学习jQuery必须知道常用的几种方法
- 学习jQuery必须知道常用的几种方法
- 学习jQuery必须知道的几种常用方法
- 小甲鱼PE详解之区块表(节表)和区块(节)续(PE详解05)
- "System.Configuration.ConfigurationSettings.AppSettings”已过时,解决办法
- SpringSecurity3.1.2控制一个账户同时只能登录一次
- 换dashboard 的背景图片
- PS常用技巧
- 学习Java类必须知道的几点
- 小甲鱼PE详解之区块描述、对齐值以及RVA详解(PE详解06)
- KKME医学搜索
- 北大POJ题库使用指南
- PPPoE拨号流程
- Spring 声明式事物配置文件解析
- 老道关于分区表的管理(三) 维护篇
- adadelta的实现
- 由一张暴利的地图获得的珍贵启示_——————_SADF3443