[读书笔记]Java编程思想第2章之一切都是对象

Posted 2021-10-08 Spring-_-Bear

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[读书笔记]Java编程思想第2章之一切都是对象相关的知识，希望对你有一定的参考价值。

堆栈位于RAM，通过堆栈指针可以直接从处理器那里获得直接支持。堆栈指针向下移动，则分配新的内存；若向上移动，则释放那些内存。这是一种快速分配有效的分配存储方法，仅次于寄存器。创建程序时，Java系统必须知道存储在堆栈内所有项的确切生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些Java数据存储于堆栈中------特别是对象引用，但是Java对象并不存储于其中。
堆是一种通用的内存池(也位于RAM区)，用于存放所有的Java对象。堆不同于堆栈的好处是：编译器不需要知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。当需要一个对象时，只需用new写一行简单的代码，当执行这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代价：用堆进行存储分配和清理时比用堆栈需要更多的时间。
特例：基本数据类型创建的自动变量直接存储“值”，并置于堆栈中，因此更加高效。

基本类型	大小	最小值	最大值	包装器类型
boolean	-	-	-	Boolean
char	16bits	Unicode 0	Unicode 2¹⁶-1	Character
byte	8bits	-128	+127	Byte
short	16bits	-2¹⁵	+2¹⁵-1	Short
int	32bits	-2³¹	+2³¹-1	Integer
long	64bits	-2⁶³	+2⁶³-1	Long
float	32bits	IEEE754	IEEE754	Float
double	64bits	IEEE754	IEEE754	Double
void	-	-	-	Void

所有数值类型都有正负号，所以不要去寻找无符号的数值类型。
boolean类型所占存储空间的大小没有明确指定，仅定义为能够取字面值true或false。
基本类型具有的包装器类，使得可以在堆中创建一个非基本对象，用来表示对应的基本类型。例如：

char c = 'x';
Character ch = new Character(c);
/* 也可以这样用 */
Character ch = new Character('x');
/* Java的自动包装功能将自动把基本类型装换成包装器类型 */
Character ch = 'x';
/* 也可以反向转换 */
char c = ch;

Java提供了两个用于高精度计算的类：BigInteger和BigDecimal。虽然它们大体上属于“包装器类”的范畴，但二者都没有对应的基本类型。
BigInteger支持任意精度的整数。也就是说，在运算中，可以准确地表示任何大小的整数值，而不会丢失任何信息。
BigDecimal支持任意精度的定点数，例如，可以用它进行精确的货币计算。
在C和C++里将一个较大作用域的变量“隐藏”起来的做法，在Java里是不允许的。也就是说，下面的代码段在Java里是非法的。

{
	int x = 12;
	{
		int x = 96;	// Illegal
	}		
}

字段可以是任何类型的对象，可以通过其引用与其进行通行；也可以是基本类型中的一种(Java确保该字段获得初始值为Java意义上的0)。如果字段是对某个对象的引用，那么必须初始化该引用，以便使其与一个实际的对象相关联。
为了给一个类库生成不会与其他名字混淆的名字，Java设计者们希望程序员反过来使用自己的Internet域名。
Java消除了所谓的“向前引用问题”：即可以提前使用暂未定义的类的对象。
javadoc只能为public和protected成员进行文档注释。也可以用-private进行标记，以便把private成员的注释也包括在内。
一些可用于代码文档的javadoc标签：

标签名	作用
@see	允许用户引用其它类的文档
{@link package.class#member label}	与@see作用相似，只是它作用于行内，并且以“label”作为超链接文本而不是“See Also”
{@docRoot}	产生到文档根目录的相对路径，用于文档树页面的显式超链接
{@inheritDoc}	从当前这个类的最直接的基类中继承相关文档到当前文档注释中
@version	你认为的重要的版本信息；如果javadoc命令行使用了"-version"标记，那么就从生成的html文档中特别提取版本信息
@author	作者信息；如果javadoc命令行使用了"-author"标记，那么就从生成的HTML文档中特别提取作者信息
@since	允许你指定程序代码最早使用的版本，可以在HTML Java文档中看到它被用来指定所有的JDK版本的情况
@param	应用于方法文档中，对参数的说明
@return	描述返回值的含义
@throws	描述可能出现异常的相关信息

练习1： 创建一个类，它包含一个int域和一个char域，它们都没有被初始化，将它们的值打印出来，以验证Java执行了默认初始化。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 11:15
 */
public class Test1 {
    int temp;
    char ch;

    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.temp);
        System.out.println(test1.ch);
    }
}

练习2： 参照本章的HelloDate.java这个例子，创建一个"Hello,World"程序，该程序只要输出这句话即可。你所编写的类里只需一个方法(即“main”方法，该程序启动时执行）。记住要把它设为static形式，并指定参数列表------即使根本不会用到这个列表。用javac进行编译，再用java运行它。如果你使用的是不同于JDK的开发环境，请了解如何在你的环境中进行编译和运行。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 14:17
 */
public class Test2 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

练习3： 找出含有ATypeName的代码段，将其改写成完成的程序，然后编译、运行。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 14:18
 */
public class Test3 {
    public static void main(String[] args) {
        System.out.println("Hello Java!");
    }
}

练习4： 将DataOnly代码段改写成一个程序，然后编译、运行。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 14:19
 */
public class Test4 {
    int i ;
    double d;
    boolean b;

    public static void main(String[] args) {
        Test4 test4 = new Test4();
        System.out.println(test4.i);
        System.out.println(test4.d);
        System.out.println(test4.b);
    }
}

练习5： 修改前一个练习，将DataOnly中的数据在main()方法中赋值并打印出来。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/18 16:01
 */

public class Test5 {
    int i ;
    double d;
    boolean b;

    public static void main(String[] args) {
        Test5 test5 = new Test5();

        test5.i = 250;
        test5.d = 380D;
        test5.b = false;

        System.out.println(test5.i);
        System.out.println(test5.d);
        System.out.println(test5.b);
    }
}

练习6： 编写一个程序，让它含有本章所定义的storage()方法的代码段，并调用之。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 14:22
 */
public class Test6 {
    int storage(String s) {
        return s.length() * 2;
    }

    public static void main(String[] args) {
        String s = "I am so interested in Java";
        Test6 test6 = new Test6();
        System.out.println(test6.storage(s));
    }
}

练习7： 将Incrementable的代码段改写成一个完整的可运行程序。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 14:25
 */
public class Test7 {
    static void increment(){StaticTest.i++;}

    public static void main(String[] args) {
        Test7.increment();
        System.out.println(StaticTest.i);
    }
}

class StaticTest{
    static int i = 47;
}

练习8： 编写一个程序，展示无论你创建了某个特定类的多少个对象，这个类中的某个特定的static域只有一个实例。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 14:29
 */
public class Test8 {
    static int temp = 0;

    public static void set(int num) {
        temp = num;
    }

    public static void main(String[] args) {
        Test8 test1 = new Test8();
        Test8 test2 = new Test8();
        Test8 test3 = new Test8();

        System.out.println(test1.temp);
        System.out.println(test2.temp);
        System.out.println(test3.temp);

        test1.set(38);

        System.out.println(test1.temp);
        System.out.println(test2.temp);
        System.out.println(test3.temp);
    }
}

练习9： 编写一个程序，展示自动包装功能对所有的基本类型和包装器类型都起作用。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 15:19
 */
public class Test9 {
    public static void main(String[] args) {
        byte be= 8;
        boolean bn = false;
        short st = 250;
        char cr = 'c';
        int it = 380;
        float ft = 123;
        long lg = 456;
        double de = 789;

        Byte Be = be;
        Boolean Bn = bn;
        Short St = st;
        Character Cr = cr;
        Integer It = it;
        Float Ft = ft;
        Long Lg = lg;
        Double De = de;

        System.out.println("byte:" + be + "; Byte:" + Be);
        System.out.println("boolean:" + bn + " Boolean:" + Bn);
        System.out.println("short:" + st + " Short:" + St);
        System.out.println("char:" + cr + " Character:" + Cr);
        System.out.println("int:" + it + " Integer:" + It);
        System.out.println("float:" + ft + " Float:" + Ft);
        System.out.println("long:" + lg + " Long:" + Lg);
        System.out.println("double:" + de + " Double:" + De);
    }
}

练习10： 编写一个程序，打印出从命令行获得的三个参数。为此，需要确定命令行数组中String的下标。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/17 15:21
 */
public class Test10 {
    public static void main(String[] args) {
        for(int i = 0;i<args.length;i++)
        {
            System.out.println(args[i]);
        }
    }
}

练习11： 将AllTheColorsOfTheRainbow这个示例改写成一个程序，然后编译、运行。

package thinkinjava.charpenter2;

/**
 * @author Spring-_-Bear
 * @create 2021/9/18 16:26
 */
public class Test11 {
    public static void main(String[] args) {
        AllTheColorsOfTheRainbow atc = new AllTheColorsOfTheRainbow();
        System.out.println("atc.anIntegerRepresentingColors = " + atc.anIntegerRepresentingColors);
        atc.changeColor(7);
        atc.changeTheHueOfTheColor(77);
        System.out.println("After color change, atc.anIntegerRepresentingColors = " + atc.anIntegerRepresentingColors);
        System.out.println("atc.hue = " + atc.hue);
    }
}

class AllTheColorsOfTheRainbow {
    int anIntegerRepresentingColors = 0;
    int hue = 0;

    void changeTheHueOfTheColor(int newHue) {
        hue = newHue;
    }

    int changeColor(int newColor) {
        return anIntegerRepresentingColors = newColor;
    }
}

练习12： 找出HelloData.java的第二个版本，也就是那个简单注释的文档的示例。对该文件执行javadoc，然后通过web浏览器观看运行结果。

package thinkinjava.charpenter2;

import java.util.Date;

/**
 * @author Spring-_-Bear
 * @version  2021/9/18 16:38
 */
public class Test12 {
    /** Entry point to class and application.
     * @param args array of string arguments
     */
    public static void main(String[] args) {
        System.out.println("Hello it's " + new Date());
    }
}

练习13： 通过javadoc运行Documentation1.java，Documentation2.java，Documentation3.java，然后通过Web浏览器验证所产生的文档。

// object.Documentation1.java
// TIJ4 Chapter Object, Exercise 13 - 1
/* Run Documentation1.java, Documentation2.java and Documentation3.java 
* through Javadoc. Verify the resulting documentation with your Web browser. 
*/

/** A class comment */
public class Documentation1 {
	/** A field comment */
	public int i;
	/** A method comment */
	public void f() {}
}

// object.Documentation1.java
// TIJ4 Chapter Object, Exercise 13 - 2
/* Run Documentation1.java, Documentation2.java and Documentation3.java 
* through Javadoc. Verify the resulting documentation with your Web browser. 
*/
import java.util.*;

// object/Documentation2.java
/**
* <pre>
* Uses
* System.out.println(new Date());
* </pre>
*/ 

public class Documentation2 {
	Date d = new Date();
	void showDate() {
	 System.out.println("Date = " + d);
	}
}

// object.Documentation1.java
// TIJ4 Chapter Object, Exercise 13 - 3
/* Run Documentation1.java, Documentation2.java and Documentation3.java 
* through Javadoc. Verify the resulting documentation with your Web browser. 
*/
import java.util.*;

// object/Documentation3.java
/**
* You can even insert a list:
* <ol>
* <li> Item one
* <li> Item two
* <li> Item three
* </ol>
*/ 

public class Documentation3 {
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println("d = " + d);
	}
}

练习14： 在前一个练习的文档中加入各项的HTML列表。

// object/Documentation4.java
// TIJ4 Chapter Object, Exercise 14, page 90
// Add an HTML list of items to the documentation in the previous exercise.
import java.util.*;

// object/Documentation4.java
/**
* You can even insert a list:
* <ol>
* <li> Item one
* <li> Item two
* <li> Item three
* </ol>
 

		
		* Another test list
		* <ol>
		* <li> One
		* <li> Two
		* <li> Three
		* </ol>
		*/	

public class Documentation4 {

		/** Let's try a public field list
		* <ol>
		* <li> One
		* <li> Two
		* <li> Three
		* </ol>
		*/	
		
		public int i = 2;

		/**
		* A private field list (-private to see) 
		* <ol>
		* <li> One
		* <li> Two
		* <li> Three
		* </ol>
		*/	

		private int j = 3;

		/**
		* Another list can be inserted here to help explain the
		* following method call
		* <ol>
		* <li> One
		* <li> Two
		* <li> Three
		* </ol><br>
		* but may be formatted differently in Method Summary
		*/	

	public static void main(String[] args) {

		/**
		* Let's try another test list here
		* <ol>
		* <li> One
		* <li> Two
		* <li> Three
		* </ol>
		*/	

		Date d = new Date();
		System.out.println("d = " + d);
	}
}

练习15： 使用练习2的程序，加入注释文档。用javadoc提取此注释文档，并产生一个HTML文件，然后通过Web浏览器查看结果。

// object/HelloDocTest.java
// TIJ4 Chapter Object, Exercies 15, page 91
/* Take the program in Exercise 2 and add comment documentation to it. Extract
* this comment documentation into an HTML file using Javadoc and view it with
* your Web browser.
*/


/** 
* Public class contained in file of the same name that includes main()
*/

public class HelloDocTest {

	/** main method executed by java
	*/	

	public static void main(String[] args) {
	System.out.println("Hello World!");
	}
}

练习16： 找到第5章的Overloading.java，并为它加入javadoc文档，然后用javadoc提取此文档注释，并产生一个HTML文件，最后，通过Web浏览器查看结果。

// object/Overloading.java
// TIJ4 Chapter Object, Exercise 16, page 91
/* In the Initialization and Cleanup chapter, locate the Overloading.java
* example and add Javadoc documentation. Extract this comment documentation
* into and HTML file using Javadoc and view it with your Web browser.
*/

// initialization/Overloading.java
// Demonstration of both constructor
// and ordinary method overloading.

/** creates type Tree wth two constructors and one info method
*/

class Tree {
	int height;
	
	/** no-argument constructor
	* assigns height = 0
	*/

	Tree() {
		System.out.println("Planting a seedling");
		height = 0;
	}

	/** constructor taking an int argument,
	* assigns height that int argument
	*/

	Tree(int initialHeight) {
		height = initialHeight;
		System.out.println("Creating new tree that is " + height + " feet tall");
	}

	/** method to print height of tree object
	*/
	
	void info() {
		System.out.println("Tree is " + height + " feet tall");
	}

	/** overloaded method to print string argument 
	* and height of a tree object
	*/

	void info(String s) {
		System.out.println(s + ": Tree is " + height + " feet tall");
	}
}

/** class to test construction of tree objects
*/

public class Overloading {
	public static void main(String[] args) {
		for(int i = 0; i < 5; i++) {
			Tree t = new Tree(i)[读书笔记]Java编程思想第3章之操作符
 [读书笔记]Java编程思想第9章之接口
 [读书笔记]Java编程思想
 [读书笔记]Java编程思想第6章之访问权限控制
 [读书笔记]Java编程思想第8章之多态
 [读书笔记]Java编程思想第4章之控制执行流程