Java 编程思想 第五章 初始化与清理 上

Posted 2020-08-04

 

 

 

　　休整几天，闲了蛋疼也没写文章，这开学了坚持每天写//

　　必须的天天写。不敢再松懈了。羡慕一好朋友能坚持的静下心来学习。

 

 

　　5.1　　用构造器确保初始化

　　　　在Java中，通过提供构造器，类的设计者可确保每个对象都会得到初始化。

　　　　  创建对象时，如果其类具有构造器，Java就会在用户有能力操作兑现之前自动调用相应的构造器，从而保证了初始化的进行。

　　　　  当然了 接下来的我们需要的问题是：

　　　　　　1、所取的任何名字都可能与类的某个成员名称相冲突；

　　　　　　2、调用股早期是编译器的责任，所以必须让编译器知道应该调用哪个方法；

　　　　 采取的方案是和C++中采用的方案一样：即构造器采用与类相同的名称。

 

下面就该贴出我们的一个带有构造器的简单类了：

 1 2 
 3 /*
 4  *         用构造器确保初始化
 5  */
 6 
 7 class Rock{
 8     Rock(){
 9         //This is the constructor
10         System.out.print("Rock ");
11     }
12 }
13 
14 public class SimpleConstructor {
15 
16     public static void main(String[] args) {
17         for(int i = 0;i < 10; i++)
18             new Rock();
19         
20     }
21 
22 }

 

/*/Output

1 Rock Rock Rock Rock Rock Rock Rock Rock Rock Rock 

　　　　如上代码中：

　　　　在创建对象 new Rock() 时 ，将会为对象分配储存空间，并调用相应的构造器，就确保你在操作对象时，它已经恰当的被初始化了。

　　　　注意：构造器的名称必须与类名完全相同。

 

　　　　以上 不接受任何参数的构造器叫做 默认构造器，下面来贴出一个有参数的构造器//

 

 1 /*
 2  *      用构造器确保初始化 - 2
 3  */
 4 
 5 class Rock2{
 6     Rock2(int i){
 7         System.out.print("Rock " + i + " ");
 8     }
 9 }
10 
11 public class SimpleConstructor2 {
12 
13     public static void main(String[] args) {
14         for (int i =0 ; i < 8 ; i++)
15             new Rock2(i);
16     }
17 
18 }

 

/*/Output

1 Rock 0 Rock 1 Rock 2 Rock 3 Rock 4 Rock 5 Rock 6 Rock 7 

 

　　　　如果Tree(int)是Tree类中唯一的构造器，那么编译器将不会允许你以其他任何方式创建Tree对象。

　　　　构造器是一种特殊类型的方法，因为它没有返回值。这与返回值为空（void）明显不同。对于空返回值，尽管方法本身不会自动返回什么，但仍可选择让它返回别的东西，构造器则不会返回任何东西，(new表达式确实返回了对新建对象的引用，但构造器本身并没有人和返回值)。假如构造器具有返回值，并且允许人们自行选择返回类型，那么势必得让编译器知道该如何出事此返回值。

 

 

　　5.2　　方法重载

　　　　贴个代码吧更容易看懂 这个同时示范了重载的构造器和重载方法。

 1 /*
 2  *         方法的重载
 3  */
 4 
 5 class Tree{
 6     int height;
 7     Tree(){
 8         System.out.println("Planting a seedling");
 9         height=0;
10     }
11     Tree(int initialheight){
12         height = initialheight;
13         System.out.println("Creating new Tree that is " + height + " feet tall ");
14     }
15     void info(){
16         System.out.println("Tree is " + height + " feet tall ");
17     }
18     void info(String s){
19         System.out.println(s + ": Tree is " + height + " feet tall ");
20     }
21 }
22 
23 public class Overloading {
24 
25     public static void main(String[] args) {
26         for(int i =0 ; i < 5 ; i++){
27             Tree t = new Tree(i);
28             t.info();
29             t.info("overloaded method");
30         }
31     }
32 
33 }

/*/Output

 

 1 Creating new Tree that is 0 feet tall 
 2 Tree is 0 feet tall 
 3 overloaded method: Tree is 0 feet tall 
 4 Creating new Tree that is 1 feet tall 
 5 Tree is 1 feet tall 
 6 overloaded method: Tree is 1 feet tall 
 7 Creating new Tree that is 2 feet tall 
 8 Tree is 2 feet tall 
 9 overloaded method: Tree is 2 feet tall 
10 Creating new Tree that is 3 feet tall 
11 Tree is 3 feet tall 
12 overloaded method: Tree is 3 feet tall 
13 Creating new Tree that is 4 feet tall 
14 Tree is 4 feet tall 
15 overloaded method: Tree is 4 feet tall 

　　　　创建Tree对象时，既可以不含参数，也可以用树的高度当参数。

　　　　前者表示一棵树苗，后者表示已有一定高度的树木。要支持这种创建方式，得有一个默认构造器和一个采用现有高度作为参数的构造器。

 

 

　　5.2.1　　区分重载方法

　　　　可以根据参数的顺序不同来区分。　　警告：一般别这么做，很容易混肴。

　　　　 贴出代码吧，

 1 /*
 2  *         区别重载方法
 3  */
 4 
 5 public class OverloadingOrder {
 6 
 7     static void f(String s, int i){
 8         System.out.println("String: " + s + ", int: " + i);
 9     }
10     static void f(int i, String s){
11         System.out.println("int: " + i +", String: " + s);
12     }
13     public static void main(String[] args) {
14         f("String first", 11);
15         f(11, "Int first");
16     }
17 }

/*/Output

 

1 String: String first, int: 11
2 int: 11, String: Int first

　　　　　**声明相同的参数，顺序不同，得以区分。

 

 

 

　　5.2.2　　涉及基本类型的重载

　　　　基本类型能从一个“较小”的类型自动提升至一个“较大”的类型，此过程一旦牵涉到重载，可能会造成一些混淆。以下贴出来个代码来说明将基本类型传递给重载方法时发生的情况。

　　　　代码太长，折叠了。

 

  1 /*
  2  *         涉及基本类型的重载
  3  *         基本类型从一个‘较小’的类型自动升至一个‘较大’的类型
  4  */
  5 
  6 
  7 public class PrimitiveOverloading {
  8 
  9     void f1(char x){    System.out.println("f1(char) ");}
 10     void f1(byte x){    System.out.println("f1(byte) ");}
 11     void f1(short x){    System.out.println("f1(short) ");}
 12     void f1(int x){    System.out.println("f1(int) ");}
 13     void f1(long x){    System.out.println("f1(long) ");}
 14     void f1(float x){    System.out.println("f1(float) ");}
 15     void f1(double x){    System.out.println("f1(double) ");}
 16     
 17     void f2(byte x){    System.out.println("f2(byte) ");}
 18     void f2(short x){    System.out.println("f2(short) ");}
 19     void f2(int x){        System.out.println("f2(int) ");}
 20     void f2(long x){    System.out.println("f2(long) ");}
 21     void f2(float x){    System.out.println("f2(float) ");}
 22     void f2(double x){    System.out.println("f2(double) ");}
 23     
 24     void f3(short x){    System.out.println("f3(short) ");}
 25     void f3(int x){        System.out.println("f3(int) ");}
 26     void f3(long x){    System.out.println("f3(long) ");}
 27     void f3(float x){    System.out.println("f3(float) ");}
 28     void f3(double x){    System.out.println("f3(double) ");}
 29     
 30     void f4(int x){        System.out.println("f4(int) ");}
 31     void f4(long x){    System.out.println("f4(long) ");}
 32     void f4(float x){    System.out.println("f4(float) ");}
 33     void f4(double x){    System.out.println("f4(double) ");}
 34     
 35     void f5(long x){    System.out.println("f5(long) ");}
 36     void f5(float x){    System.out.println("f5(float) ");}
 37     void f5(double x){    System.out.println("f5(double) ");}
 38     
 39     void f6(float x){    System.out.println("f6(float) ");}
 40     void f6(double x){    System.out.println("f6(double) ");}
 41     
 42     void f7(double x){    System.out.println("f7(double) ");}
 43     
 44     
 45     void testConstVal(){
 46         System.out.println("5: ");
 47         f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);
 48         System.out.println();
 49     }
 50     void testChar(){
 51         char x = ‘x‘;
 52         System.out.println("char: ");
 53         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 54         System.out.println();
 55     }
 56     void testByte(){
 57         byte x = 0;
 58         System.out.println("Byte: ");
 59         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 60         System.out.println();
 61     }
 62     void testShort(){
 63         short x = 0;
 64         System.out.println("Short:");
 65         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 66         System.out.println();
 67     }
 68     void testInt(){
 69         int x = 0;
 70         System.out.println("Int: ");
 71         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 72         System.out.println();
 73     }
 74     void testLong(){
 75         long x = 0;
 76         System.out.println("Long: ");
 77         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 78         System.out.println();
 79     }
 80     void testFloat(){
 81         float x = 0;
 82         System.out.println("Float: ");
 83         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 84         System.out.println();
 85     }
 86     void testDouble(){
 87         double x = 0;
 88         System.out.println("Float: ");
 89         f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
 90         System.out.println();
 91     }
 92     
 93     
 94     public static void main(String[] args) {
 95         PrimitiveOverloading p = new PrimitiveOverloading();
 96         p.testConstVal();
 97         p.testChar();
 98         p.testByte();
 99         p.testShort();
100         p.testInt();
101         p.testLong();
102         p.testFloat();
103         p.testDouble();
104     }
105 
106 }

View Code

 

/**/Output

 1 5: 
 2 f1(int) 
 3 f2(int) 
 4 f3(int) 
 5 f4(int) 
 6 f5(long) 
 7 f6(float) 
 8 f7(double) 
 9 
10 char: 
11 f1(char) 
12 f2(int) 
13 f3(int) 
14 f4(int) 
15 f5(long) 
16 f6(float) 
17 f7(double) 
18 
19 Byte: 
20 f1(byte) 
21 f2(byte) 
22 f3(short) 
23 f4(int) 
24 f5(long) 
25 f6(float) 
26 f7(double) 
27 
28 Short:
29 f1(short) 
30 f2(short) 
31 f3(short) 
32 f4(int) 
33 f5(long) 
34 f6(float) 
35 f7(double) 
36 
37 Int: 
38 f1(int) 
39 f2(int) 
40 f3(int) 
41 f4(int) 
42 f5(long) 
43 f6(float) 
44 f7(double) 
45 
46 Long: 
47 f1(long) 
48 f2(long) 
49 f3(long) 
50 f4(long) 
51 f5(long) 
52 f6(float) 
53 f7(double) 
54 
55 Float: 
56 f1(float) 
57 f2(float) 
58 f3(float) 
59 f4(float) 
60 f5(float) 
61 f6(float) 
62 f7(double) 
63 
64 Float: 
65 f1(double) 
66 f2(double) 
67 f3(double) 
68 f4(double) 
69 f5(double) 
70 f6(double) 
71 f7(double) 

View Code

　　　　打开看看 想想//

　　　　其中常数值5被当作int值处理，所以如果有某个重载方法接受int型参数，它就会被调用。至于其他情况，如果传入的数据类型(实际参数类型)小于方法中声明的形式参数类型。实际数据类型就会被提升。

　　　　char型略有不同，如果无法找到恰好接受char参数的方法，就会把char直接提升至int型。

 

　　　　但是如果呢。传入的实际参数大于重载方法声明的形式参数/粗线的情况呢，看下面

 1 /*
 2  *         实际参数大于重载方法声明的形式参数。
 3  * 
 4  */
 5 
 6 
 7 
 8 public class Demotion {
 9     
10     void f1(char x){    System.out.println("f1(char) ");}
11     void f1(byte x){    System.out.println("f1(byte) ");}
12     void f1(short x){    System.out.println("f1(short) ");}
13     void f1(int x){        System.out.println("f1(int) ");}
14     void f1(long x){    System.out.println("f1(long) ");}
15     void f1(float x){    System.out.println("f1(float) ");}
16     void f1(double x){    System.out.println("f1(double) ");}
17     
18     void f2(char x){    System.out.println("f2(char) ");}
19     void f2(byte x){    System.out.println("f2(byte) ");}
20     void f2(short x){    System.out.println("f2(short) ");}
21     void f2(int x){        System.out.println("f2(int) ");}
22     void f2(long x){    System.out.println("f2(long) ");}
23     void f2(float x){    System.out.println("f2(float) ");}
24 
25     void f3(char x){    System.out.println("f3(char) ");}
26     void f3(byte x){    System.out.println("f3(byte) ");}
27     void f3(short x){    System.out.println("f3(short) ");}
28     void f3(int x){        System.out.println("f3(int) ");}
29     void f3(long x){    System.out.println("f3(long) ");}
30 
31     void f4(char x){    System.out.println("f4(char) ");}
32     void f4(byte x){    System.out.println("f4(byte) ");}
33     void f4(short x){    System.out.println("f4(short) ");}
34     void f4(int x){        System.out.println("f4(int) ");}
35     
36     void f5(char x){    System.out.println("f5(char) ");}
37     void f5(byte x){    System.out.println("f5(byte) ");}
38     void f5(short x){    System.out.println("f5(short) ");}
39     
40     void f6(char x){    System.out.println("f6(char) ");}
41     void f6(byte x){    System.out.println("f6(byte) ");}
42     
43 
44     void f7(char x){    System.out.println("f7(char) ");}
45     
46     
47     void testDouble(){
48         double x = 0;
49         System.out.println("double argument:");
50         f1(x);f2((float)x);f3((long)x);f4((int)x);f5((short)x);f6((byte)x);f7((char)x);
51     }
52     
53     
54     public static void main(String[] args) {
55         Demotion p = new Demotion();
56         p.testDouble();
57     }
58 
59 }

View Code

/**/ Output

1 double argument:
2 f1(double) 
3 f2(float) 
4 f3(long) 
5 f4(int) 
6 f5(short) 
7 f6(byte) 
8 f7(char) 

　　　　这里，方法接受较小的基本类型作为参数。如果传入的实际参数较大，就的通过类型转换来执行窄化转换。如果不这么做，编译器会报错/

 

 

　　　　　　　　　　　　　　　　　　　　勿忘初心　　方得始终