- 创建一个类,它包含一个未初始化的String引用。验证该引用被Java初始化成了null
package net.mindview.initialization;
public class Test1 {
public String str;
static void main(String[] args) {
Test1 t = new Test1();
System.out.println(t.str);
}
}
返回结果
null
?
- 创建一个类,它包含一个在定义时就被初始化了的String域,以及另一个通过构造器初始化的String域,这两种方式有何差异?
Test2 {
public String str1 = "abc";
String str2;
Test2(){
System..println(str1);
System..println(str2);
this.str2 = def;
System..println(str2);
}
main(String[] args) {
Test2 t = Test2();
}
}
运行结果:
abc
null
abc
def
结论: 定义是就被初始化的str1只被赋值一次,而定义时未被初始化str2被赋值了两次,第一次是null,第二次是构造器赋值.
- 创建一个带默认构造器的类,在构造器中打印一条消息. 为这个类创建一个对象.
Test3 {
Test3(){
System.out.println(默认构造器);
}
main(String[] args) {
Test3 t = Test3();
}
}
?
- 为前一个联系中的类添加一个冲在构造器,令其接受一个字符串参数,并在构造器中吧自己的消息和接受的参数一起打印出来.
);
}
Test3(String str){
System.有一个参数的构造器);
System..println(str);
}
Test3();
Test3 t2 = new Test3(hello);
}
}
?
- 创建一个名为dog的类,它具有重载的bark()方法,此方法根据不同的基本数据类型重载,并根据被调用的版本,打印出不同类型的狗吠(barking),咆哮(howling)等信息.编写main()来调用所有不同版本的方法
Dog {
bark(){
System.barking bark(String paoxiao){
System.howling main(String[] args) {
Dog dog1 = Dog();
dog1.bark();
dog1.bark(paoxiao);
}
}
?
- (略)
- (略)
-
编写具有两个方法的类，在第一个方法内调用第二个方法两次：第一次调用时不使用this关键字，第二次调用时使用this关键字-- * 这里只是为了验证它是起作用的，你不应该在实践中使用这种方法。
Test8 {
method1(){
System.1);
method2().method2();
}
Test8 method2(){
System.2);
return this;
}
main(String[] args) {
Test8 t = Test8();
t.method1();
}
}
?
- (略)
-
编写具有finalize（）方法的类，并在方法中打印消息，在main（）中为该类创建一个对象，试解释这个程序的行为。
Test10 {
@Override
protected finalize() throws Throwable {
System.调用了finalize方法);
super.finalize();
}
main(String[] args) {
Test10 t = Test10();
t = ;
System.gc();
Test10 t1 = Test10();
t1 = ;
System.gc();
}
}
即便我手动调用垃圾回收处理了,但finalize方法也不是每次都会被调用. 也就是说虽然我手动触发垃圾回收,但实际上,并没有真的触发垃圾回收. 下面这篇文章就解释原因:http://blog.csdn.net/yewei02538/article/details/52386642
-
修改前一个练习的程序,让你的finalize（）总会被调用。
-
（4）编写名为Tank的类，此类的状态可以是“满的”或“空的”。其终结条件是：对象被清理时必须处于空状态。??* 请编写finalize（）以检验终结条件是否成立，在main（）中测试Tank可能发生的几种使用方式
Tank {
public String state = empty;
Tank(String state){
this.state = state;
}
clear(){
this.state = ;
}
@Override
------finalize---------if(!state.equals()){
System.Error!!Tank未被清空);
}
super.finalize();
}
main(String[] args) {
Tank tank1 = new Tank(full);
tank1.clear();
System.gc();
System.runFinalization();
Tank tank2 = );
tank1 = ;
tank2 = ;
System.gc();
System.runFinalization();
}
}
这里需要将tank1和tank2手动置为空. 否则垃圾回收机制会将其标记,然后再下一个周期清除.
- (略)
-
编写一个类，拥有两个静态字符串域，其中一个在定义处初始化，另一个在静态块中初始化。现在，加入一个静态方法用以打印出两个字段值。请证明它们都会在被使用之前完成初始化动作。
Test14 {
static String str1 = static String str2;
{
str2 = ;
}
print(){
System.str1 :"+ str1);
System.str2 : str2);
}
main(String[] args) {
print();
}
}
?
-
编写一个含有字符串域的类，并采用实例初始化方式进行初始化。??
String str3;
//静态成员初始化
;
str3 = "aaa"; 报错
}
非静态成员初始化
{
str3 = aaa;
str2 = mmm";也可以给静态成员初始化
}
main(String[] args) {
Test14 t = Test14();
print();
System.str3 : t.str3);
}
}
?
- (略)
-
创建一个类，他有一个接受一个String参数的构造器。在构造阶段，打印该参数。创建一个该类的对象引用数组，但是不实际去创建对象赋值给该数组。当运行程序时，请注意来自对该构造器的调用中的初始化消息是否打印了出来
Test17 {
Test17(String str){
System..println(str);
}
main(String[] args) {
Test17[] tt = ;
}
}
只有实例化的时候才会调用构造方法
-
通过创建对象赋值给引用数组，从而完成前一个练习。
package net.mindview.initialization;
import java.util.Random;
main(String[] args) {
Random rand = Random();
Test17[] tt = new Test17[rand.nextInt(100)];
for(int i=0;i<tt.length; i++){
tt[i] = new Test17(""+i);
}
}
}
?
-
写一个类，他接受一个可变参数的String数组，验证你可以向该方法传递一个用逗号分隔的String列表，或是一个String[]。
Test19 {
print(String ...strings){
for(String str: strings){
System..print(str);
}
System..println();
}
main(String[] args) {
Test19 t = Test19();
t.print(",bbbccc);
t.print(new String[]{def});
}
}
?
-
创建一个使用可变参数列表而不是普通的main()语法的main()。打印所产生的args数组的所有元素，并用各种不同数量的命令行参数来测试它。
Test19 {
main(String ...args){
(String arg: args){
System..println(arg);
}
}
}
?
-
创建一个enum，它包含纸币中最小面值的6种类型。通过values()循环并打印每一个值及其ordinal()
enum Money{
ONE,TWO,FIVE,TEN,FIVTY,HUNDRED
}
Test21 {
main(String[] args) {
(Money m : Money.values()){
System.out.println(m + " " + m.ordinal());
}
}
}
?
-
在前面的例子中，为enum写一个switch语句，对于每一个case，输出该特定货币的描述。
Test22 {
Money value;
Test22(Money value){
this.value = value;
}
printValue(){
switch(value){
case ONE:
System.1元面值);
break;
TWO:
System.2元面值 FIVE:
System.5元面值 TEN:
System.10元面值 FIFTY:
System.50元面值 HUNDRED:
System.100元面值;
}
}
main(String[] args) {
Test22 t = Test22(Money.ONE);
Test22 t2 = Test22(Money.TWO);
Test22 t3 = Test22(Money.HUNDRED);
t.printValue();
t2.printValue();
t3.printValue();
}
}
?
