本文主要依据《Java编程思想》的示例及课后练习，通过个人编写，同时参考答案的代码写法。主要目的是用于自己熟悉编码风格，同时可以给更多人提供参考。（只完成了部分练习）
练习1：
/**
* @作者 Jiacy
* @日期2021年4月12日
* @描述：创建一个类，它包含了一个未初始化的String引用。验证该引用被Java初始化成null。
* @version
*
*/
public class lesson1 {
String s;
public static void main(String[] args) {
lesson1 stri = new lesson1();
System.out.println("stri = " + stri.s);
}
}
运行结果：
stri = null
练习2：
/**
* @作者 Jiacy
* @日期2021年4月12日
* @描述：创建一个类，它包含一个在赢一时就被初始化了的String域，以及另一个通过构造器初始化的String域。
* @version
*
*/
public class lesson2 {
String s1 = "已经初始化的String域";//定义时初始化的String域
String s2;
public lesson2(String s21) {//构造器
s2 = s21;
}
public static void main(String[] args) {
lesson2 si = new lesson2("通过构造器初始化的String域");//通过构造器初始化的String域
System.out.println("si.s1 = " + si.s1);
System.out.println("si.s2 = " + si.s2);
}
}
运行结果：
si.s1 = 已经初始化的String域
si.s2 = 通过构造器初始化的String域
练习3：
/**
* @作者 Jiacy
* @日期2021年4月13日
* @描述：创建一个带默认构造器的类，在构造器中打印一条消息。
* 为这个类创建一个对象。
* @version
*
*/
public class lesson3 {
lesson3(){
System.out.println("默认构造器");
}
public static void main(String[] args) {
new lesson3();
}
}
运行结果：
默认构造器
练习4：
package 初始化与清理;
/**
* @作者 Jiacy
* @日期2021年4月13日
* @描述：为前一个练习中的类添加一个重载构造器，令其接受一个字符串参数，并在构造器中把你自己的消息
* 和接收的参数一起打印出来
* @version
*
*/
public class lesson4 {
lesson4(){
System.out.println("默认构造器");//默认构造器
}
lesson4(String s){//重载构造器
System.out.println("重载构造器");
System.out.println(s);
}
public static void main(String[] args) {
new lesson4();//创建默认构造器的对象
new lesson4("String");//窗前重载构造器的对象
}
}
运行结果：
默认构造器
重载构造器
String
练习5：
package 初始化与清理;
/**
* @作者 Jiacy
* @日期2021年4月14日
* @描述：创建一个名为Dog的类，它具有重载的bark()方法。此方法应根据不同的基本数据类型进行重载，
* 并根据被调用的版本，打印出不同类型的狗吠（barking）、咆哮（howling）等信息
* @version
*
*/
public class lesson5 {
public void bark() {
System.out.println("默认叫声");
}
public void bark(int i) {//重用方法1
System.out.println("howling!");
}
public void bark(double i) {//重用方法2
System.out.println("汪！");
}
public void bark(String i) {//重用方法3
System.out.println("嘤嘤嘤");
}
public static void main(String[] args) {
lesson5 dog = new lesson5();
dog.bark();//调用默认类
dog.bark(1);//调用重用方法1
dog.bark(1.0);//调用重用方法2
dog.bark("s");//调用重用方法3
}
}
运行结果：
默认叫声
howling!
汪！
嘤嘤嘤
练习6：
package 初始化与清理;
/**
* @作者 Jiacy
* @日期2021年4月14日
* @描述：修改练习5，让重载方法各自接受两个类型不同的参数，但顺序相反。
* @version
*
*/
public class lesson6 {
public void bark() {
System.out.println("默认叫声");
}
public void bark(int i,double j) {//重用方法1
System.out.println("howling!");
}
public void bark(double i,int j) {//重用方法2
System.out.println("汪！");
}
public static void main(String[] args) {
lesson6 dog = new lesson6();
dog.bark();//调用默认类
dog.bark(1,1.5);//调用重用方法1
dog.bark(15.1,1);//调用重用方法2
}
}
运行结果：
默认叫声
howling!
汪！
练习7：
package 初始化与清理;
/**
* @作者 Jiacy
* @日期2021年4月14日
* @描述：创建一个没有构造器的类，并在main()方法中创建其对象，用以验证编译器是否真的自动加入了默认构造器
* @version
*
*/
public class lesson7 {
public static void main(String[] args) {
new lesson7();//直接创建
}
}
练习8：
package 初始化与清理;
/**
* @作者 Jiacy
* @日期2021年4月16日
* @描述：编写具有两个方法的类，在第一个方法内调用第二个方法两次：
* 第一次调用时不使用this关键字，第二次调用时使用this关键字。
* @version
*
*/
public class lesson8 {
public void b() {//第二个方法
System.out.println("b called");
}
public void a() {//第一个方法
b();//不使用this关键字
this.b();//使用this关键字
}
public static void main(String[] args) {
new lesson8().a();
}
}
运行结果：
b called
b called
练习9：
package 初始化与清理;
/**
* @作者 Jiacy
* @日期2021年4月16日
* @描述：编写一个具有两个重载构造器的类，并在第一个构造器中通过this调用第二个构造器。
* @version
*
*/
public class lesson9 {
public lesson9(String s) {//第二个重载构造器
System.out.println("s = " + s);
}
public lesson9(int i) {//第一个重载构造器
this("i = " + i);//通过this调用第二个构造器
}
public static void main(String[] args) {
new lesson9("String");
new lesson9(1);
}
}
运行结果：
s = String
s = i = 1
练习10：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：编写具有finalize()方法的类，并在方法中打印消息。
* 在main()中为该类创建一个对象。
* @version
*
*/
public class lesson10 {
protected void finalize() {
System.out.println("finalize()");
}
public static void main(String[] args) {
new lesson10();
}
}
练习11：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：修改lesson10，放finalize()总会被调用
* @version
*
*/
public class lesson11 {
protected void finalize() {
System.out.println("Finalized()");
}
public static void main(String[] args) {
new lesson11();
System.gc();
System.runFinalization();//调用finalize函数
}
}
运行结果：
Finalized()
练习12：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：编写名为Tank的类此类的状态满的或空的，其终结条件是：
* 对象被清理时，必须处于空状态。请编写finalize()以检验终结条件是否成立。
* 在main()中测试Yank可能发生的几种方式。
* @version
*
*/
class Tank{
static int counter;
int id = counter++;
boolean full;
public Tank() {
System.out.println("Tank " + id + " created");
full = true;
}
public void empty() {
full = false;
}
protected void finalize() {
if(full) {
System.out.println(id + " must be cleaned");
}
else
System.out.println(id + " is cleaned");
}
public String toString() {
return "Tank" + id;
}
}
public class lesson12 {
public static void main(String[] args) {
new Tank().empty();
new Tank();
System.gc();
System.runFinalization();
}
}
运行结果：
Tank 0 created
Tank 1 created
0 is cleaned
1 must be cleaned
练习14：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：编写一个类，拥有两个静态字符串域，其中一个在定义处初始化，另一个在静态块中初始化。
* 现在，加入一个静态方法用以打印出两个字段值。证明它们都会在被使用之前完成初始化动作。
* @version
*
*/
public class lesson14 {
static String s1 = "String s1 is initialed";//在定义处初始化的字符串
static String s2;//另一个字符串
static {
s2 = "String s2 is initialed";//在静态块中完成初始化
}
public static void main(String[] args) {
System.out.println("s1 = " + s1);
System.out.println("s2 = " + s2);
}
}
运行结果：
s1 = String s1 is initialed
s2 = String s2 is initialed
练习15：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：编写一个含有字符串域的类，并采用实例初始化方式进行初始化。
* @version
*
*/
public class lesson15 {
String s = "实例初始化";
public lesson15() {
System.out.println("默认初始化：" + s);
}
public lesson15(int i ) {
System.out.println("int初始化：" + s);
}
public static void main(String[] args) {
new lesson15();
new lesson15(1);
}
}
运行结果：
默认初始化：实例初始化
int初始化：实例初始化
练习16：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：创建一个String对象数据，并为每一个元素都赋值一个String。
* 用for循环打印该数组
* @version
*
*/
public class lesson16 {
public static void main(String[] args) {
String s[] = new String[5];//创建String对象
s[0] = "This";
s[1] = "is";
s[2] = "a";
s[3] = "String";
s[4] = "!";//为5个元素赋值
for(int i = 0;i<5;i++) {//用for循环打印数组
System.out.println(s[i]);
}
}
}
运行结果：
This
is
a
String
!
练习17：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：创建一个类，它有一个接收一个String参数的构造器。
* 在构造阶段，打印该参数。
* 创建一个该类的对象引用数组，但是不实际去创建对象赋值给该数组。
* @version
*
*/
class Test{//创建一个类，包含一个接受一个String参数的构造器
Test (String s){
System.out.println("String参数构造器");
}
}
public class lesson17 {
public static void main(String[] args) {
Test[] array1 = new Test[4];//创建该类的对象引用数组
}
}
练习18：
/**
* @作者 Jiacy
* @日期2021年4月18日
* @描述：通过创建对象赋值给引用数组，从而完成练习17
* @version
*
*/
public class lesson18 {
public static void main(String[] args) {
Test[] array1 = new Test[4];//创建该类的对象引用数组，此处Test可直接调用lesson17中的Test类
for(int i = 0;i < array1.length;i++) {
array1[i] = new Test(Integer.toString(i));
}
}
}
String参数构造器
String参数构造器
String参数构造器
String参数构造器
练习19：
/**
* @作者 Jiacy
* @日期2021年4月19日
* @描述：写一个类，它接受一个可变参数的String数组。验证你可以向该方法穿第一个用逗号分隔的
* String列表，或是一个String[]
* @version
*
*/
public class lesson19 {
static void printString(String ...str) {//可变参数
for(String s : str)
System.out.println(s);
}
public static void main(String[] args) {
printString("This","is","a","String");//用逗号分隔的String列表
printString(
new String[] {"this","is","a","String"});//String[]
}
}
运行结果：
This
is
a
String
this
is
a
String
练习20：
/**
* @作者 Jiacy
* @日期2021年4月19日
* @描述：创建一个使用可变参数列表而不是普通的main()语法的main()。
* 打印所产生的的args数组的所有元素，并用各种不同数量的命令行参数来测试它。
* @version
*
*/
public class lesson20 {
public static void main(String... args) {
lesson19.printString(args);
}
}
练习21：
/**
* @作者 Jiacy
* @日期2021年4月19日
* @描述：创建一个enum，它包含纸币中最小面值的6种类型。
* 通过values()循环并打印每一个及其ordinal()。
* @version
*
*/
enum PaperCurrencyType{
ONE,TWO,FIVE,TEN,TWENTY,FIFTY,HUNDRED
}
public class lesson21 {
public static void main(String[] args) {
for(PaperCurrencyType s : PaperCurrencyType.values())
System.out.println(s + " ordinal " + s.ordinal());//打印s和s.ordinal()
}
}
运行结果：
ONE ordinal 0
TWO ordinal 1
FIVE ordinal 2
TEN ordinal 3
TWENTY ordinal 4
FIFTY ordinal 5
HUNDRED ordinal 6
练习22：
/**
* @作者 Jiacy
* @日期2021年4月19日
* @描述：对于lesson21中，为enum写一个switch语句，对于每一个case，输出
* 该特定货币的描述。
* @version
*
*/
public class lesson22 {
static void describe(PaperCurrencyType pct) {
System.out.print(pct + "面值为");
switch(pct) {//enum的switch语句，打印对应纸币的面值
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 TWENTY:
System.out.println("20元");
break;
case FIFTY:
System.out.println("50元");
break;
case HUNDRED:
System.out.println("100元");
break;
}
}
public static void main(String[] args) {
for(PaperCurrencyType s : PaperCurrencyType.values())
describe(s);
}
}
运行结果：
ONE面值为1元
TWO面值为2元
FIVE面值为5元
TEN面值为10元
TWENTY面值为20元
FIFTY面值为50元
HUNDRED面值为100元
