练习3：（1）创建一个带默认构造器（即无参构造器）的类，在构造器中打印一条消息。为这个类创建一个对象。P116
public class Test{
public Test(){
System.out.println("Hello Word");
}
public static void main(String[] args) {
new Test();
}
/**
* 运行结果
Hello Word
*/
}
练习4：（1）为前一个练习中的类添加一个重载构造器，令其接受一个字符参数，并在构造器中把你自己的信息和接受的参数一起打印出来。
public class Test{
public Test(String msg){
System.out.println("Hello "+msg);
}
public static void main(String[] args) {
new Test("China");
}
/**
* 运行结果
Hello China
*/
}
练习5：（2）创建一个名为Dog的类，它具有重载的bark（）方法。此方法应根据不同的基本数据类型进行重载，并根据被调用的版本，打印出不同类型的狗吠（barking）、咆哮（howling）等信息，编写main（）来调用所有不同版本的方法。
public class Dog{
public void bark(){
System.out.println("barking");
}
public void bark(String name){
System.out.println(name + " howing");
}
public static void main(String[] args) {
Dog dog=new Dog();
dog.bark();
dog.bark("Lily");
}
/**
* 运行结果
barking
Lily howing
*/
}
练习6：（1）修改前一个练习的程序，让两个重载方法各自接受两个类型的不同的参数，但二者顺序相反。验证其是否工作。
public class Dog{
public void bark(int i){
System.out.println(i+"barking");
}
public void bark(String name){
System.out.println(name + " howing");
}
public static void main(String[] args) {
Dog dog=new Dog();
dog.bark("Lily");
dog.bark(88);
}
/**
* 运行结果
Lily howing
88barking
*/
}
练习7：（1）创建一个没有构造器的类，并在main（）中创建其对象，用以验证编译器是否真的自动加入了默认构造器。
public class Dog{
public void bark(int i){
System.out.println(i+"barking");
}
public void bark(String name){
System.out.println(name + " howing");
}
public static void main(String[] args) {
Dog dog=new Dog();
dog.bark("Lily");
dog.bark(88);
}
/**
* 运行结果
Lily howing
88barking
*/
}
练习8：（1）编写具有两个方法的类，在第一个方法内调用第二个方法两次：第一次调用时不使用this关键字，第二次调用时使用this关键字-- * 这里只是为了验证它是起作用的，你不应该在实践中使用这种方法。
public class Test{
public static void main(String[] args) {
Apple apple=new Apple();
apple.getApple();
}
/**
* 运行结果
未使用this调用：已创建好……
使用this调用：已创建好……
*/
}
class Apple{
public void getApple(){
System.out.print("未使用this调用：");
createApple();
System.out.print("使用this调用：");
this.createApple();
}
public void createApple(){
System.out.println("已创建好……");
}
}
练习9：（1）编写两个（重载）构造器的类，并在第一个构造器中,通过this调用第二个构造器。
package mil.oms.main.test;
public class Test{
public static void main(String[] args) {
new Apple();
}
/**
* 运行结果
颜色：red
*/
}
class Apple{
public Apple(){
this("red");
}
public Apple(String color){
System.out.println("颜色："+color);
}
}
练习10：（2）编写具有finalize（）方法的类，并在方法中打印消息，在main（）中为该类创建一个对象，试解释这个程序的行为。
public class Test{
public static void main(String[] args) {
Apple apple=new Apple();
apple=null;
System.gc();
}
/**
* 运行结果
<span style="font-family: Arial, Helvetica, sans-serif;">----finalize---------</span>
*/
}
class Apple{
protected void finalize(){
System.out.println("----finalize---------");
}
}
练习11：（4）修改前一个练习的程序,让你的finalize（）总会被调用。
public class Test{
public static void main(String[] args) {
new Apple();
System.gc();
System.runFinalization();
}
/**
* 运行结果
颜色：red
*/
}
class Apple{
protected void finalize(){
System.out.println("----finalize---------");
}
}
练习12：（4）编写名为Tank的类，此类的状态可以是“满的”或“空的”。其终结条件是：对象被清理时必须处于空状态。 * 请编写finalize（）以检验终结条件是否成立，在main（）中测试Tank可能发生的几种使用方式
public class Tank{
public boolean state=false;
public void changeState(boolean state){
this.state=state;
}
protected void finalize() throws Throwable{
if(state){
System.out.println("----满的，有问题---------");
throw new Throwable ("状态不为空!");
}else{
System.out.println("----空的，没问题---------");
super.finalize();
}
}
public static void main(String[] args) {
new Tank();
System.gc();
System.runFinalization();
new Tank().changeState(true);
System.gc();
System.runFinalization();
}
/**
* 运行结果
----空的，没问题---------
----满的，有问题---------
*/
}
练习13：（1）验证前面段落中的语句
public class ExpliciStatic{
public static void main(String[] args) {
System.out.println("Inside main()");
Cups.cup1.f1(1);
}
static Cups cups1=new Cups();
static Cups cups2=new Cups();
/**
* 运行结果
Bowl(1)
Bowl(2)
Cups()
Cups()
Inside main()
f1(1)
*/
}
class Cup{
Cup(int mark){
System.out.println("Bowl("+mark+")");
}
void f1(int mark){
System.out.println("f1("+mark+")");
}
}
class Cups{
static Cup cup1;
static Cup cup2;
static{
cup1=new Cup(1);
cup2=new Cup(2);
}
Cups(){
System.out.println("Cups()");
}
}
练习14：（1）编写一个类，拥有两个静态字符串域，其中一个在定义处初始化，另一个在静态块中初始化。现在，加入一个静态方法用以打印出两个字段值。请证明它们都会在被使用之前完成初始化动作。
public class ExpliciStatic{
public static void main(String[] args) {
Cup.print();
}
/**
* 运行结果
str1:str1
str2:str2
*/
}
class Cup{
static String str1="str1";
static String str2;
static{
str2="str2";
}
static void print(){
System.out.println("str1:"+str1);
System.out.println("str2:"+str2);
}
}
练习15：（1）编写一个含有字符串域的类，并采用实例初始化方式进行初始化。
public class ExpliciStatic{
public static void main(String[] args) {
System.out.println("start()");
new Cup();
System.out.println("end()");
}
/**
* 运行结果
start()
字段串域初始化完成
Cup()
end()
*/
}
class Cup{
String str;
{
str="Hello";
System.out.println("字段串域初始化完成");
}
Cup(){
System.out.println("Cup()");
}
}
练习16创建一个String对象数据，并为每一个元素都赋值一个String。用for循环来打印该数组。
public class ExpliciStatic{
public static void main(String[] args) {
String[] strs={"H","e","l","l","o"};
for(String str:strs){
System.out.print(str);
}
}
/**
* 运行结果
Hello
*/
}
练习17：创建一个类，他有一个接受一个String参数的构造器。在构造阶段，打印该参数。创建一个该类的对象引用数组，但是不实际去创建对象赋值给该数组。当运行程序时，请注意来自对该构造器的调用中的初始化消息是否打印了出
public class ExpliciStatic{
public static void main(String[] args) {
Random random=new Random(47);
Cup[] cups=new Cup[random.nextInt(10)];
}
/**
* 运行结果
*/
}
class Cup{
Cup(String str){
System.out.println("Cup("+str+")");
}
}
练习18：通过创建对象赋值给引用数组，从而完成前一个练习。
public class ExpliciStatic{
public static void main(String[] args) {
Random random=new Random(47);
Cup[] cups=new Cup[random.nextInt(10)];
for(int i=0,j=cups.length;i<j;i++){
cups[i]=new Cup("cup"+i);
}
}
/**
* 运行结果
Cup(cup0)
Cup(cup1)
Cup(cup2)
Cup(cup3)
Cup(cup4)
Cup(cup5)
Cup(cup6)
Cup(cup7)
*/
}
class Cup{
Cup(String str){
System.out.println("Cup("+str+")");
}
}
练习19：（1）写一个类，他接受一个可变参数的String数组，验证你可以向该方法传递一个用逗号分隔的String列表，或是一个String[]。
<pre name="code" class="html">public class ExpliciStatic{
public static void main(String[] args) {
String str="Hello",strs[]={str};
System.out.print("传 入 字 符 串 ：");
new Cup(str);
System.out.print("传入字符串数组：");
new Cup(strs);
System.out.print("传入两个字符串：");
new Cup(str,str);
}
/**
* 运行结果：
传 入 字 符 串 ：可变。。。参数
传入字符串数组：可变。。。参数
传入两个字符串：可变。。。参数
*/
}
class Cup{
Cup(String ... str){
System.out.println("可变。。。参数");
}
}
练习20：（1）创建一个使用可变参数列表而不是普通的main()语法的main()。打印所产生的args数组的所有元素，并用各种不同数量的命令行参数来测试它。
public class ExpliciStatic{
public static void main (String... args){
printStr("H","e","l","l","o");
printStr(
new String[] {"H","e","l","l","o",}/** 最后的逗号可有可无 **/
);
}
/**
* 运行结果：
Hello
Hello
*/
public static void printStr(String ... strs){
for(String str:strs){
System.out.print(str);
}
System.out.println();
}
}
练习21：创建一个enum，它包含纸币中最小面值的6种类型。通过values()循环并打印每一个值及其ordinal（）
public class ExpliciStatic{
public static void main (String args[]){
for(Money m:Money.values()){
System.out.println(m+"\t "+m.ordinal());
}
}
/**
* 运行结果：
one 0
two 1
five 2
ten 3
hun 4
tho 5
*/
}
enum Money{
one,two,five,ten,hun,tho
}
练习22：（2）在前面的例子中，为enum写一个switch语句，对于每一个case，输出该特定货币的描述。
public class ExpliciStatic{
public static void main (String args[]){
for(Money m:Money.values()){
System.out.println(m+"\t "+m.ordinal());
Money.describe(m);
}
}
/**
* 运行结果：
one 0
1分钱
two 1
2分钱
five 2
5分钱
ten 3
10块钱
hun 4
20块钱
tho 5
50块钱
*/
}
enum Money{
one,two,five,ten,hun,tho;
static void describe(Money m){
switch(m){
case one:
System.out.println("1分钱");break;
case two:
System.out.println("2分钱");break;
case five:
System.out.println("5分钱");break;
case ten:
System.out.println("10块钱");break;
case hun:
System.out.println("20块钱");break;
case tho:
System.out.println("50块钱");break;
default:break;
}
}
}
184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
