Java手记---Public,protected,private,default作用范围

Posted on Edited on Word count in article: 2.3k Reading time ≈ 2 mins.

java文件中的public 类
publicTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13

class A  
{  
    public static void main(String [] args)  
    {  
        System.out.println("hello");  
    }  
}  
  
public class PublicTest  
{  
  
}

这里编译会通过，不过运行时会给出缺省main函数的提示

在MainClass.java中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class sub  
{  
    String a;  
    int num;  
    sub()  
    {  
        a = "Hello";  
        num = 3;  
    }  
    public static void main(String []arg)  
    {  
        MainClass mc = new MainClass();  
        System.out.println(mc.s.a);  
        System.out.println(mc.s.num);  
    }  
}  
  
public class MainClass  
{  
    String t;  
    sub s;  
    MainClass()  
    {  
        s = new sub();  
        t = "hhh";  
    }  
  
}
```  
这里编译通过，运行也可以。可能是上一个类调用了MainClass  
不过要注意的一点是一个java文件中最多只有一个public类。  
只要声明成public 或省略public的类都可以在其他的java文件中调用。  
但是如果一个类没有声明是public，那么它的方法和成员有可以不能被其他文件的类看到。  
但是仍然可以使用他们。不过这个类中的私有成员不能被访问，其他类型的都可以。  
详见：PublicTest.java 与PublicTest1.java  
一个类可以有多个子类，但不能有多个超类.  
java中没有缺省值。这里的缺省值是指函数中参数的缺省。如test（int a ＝ 0）这样写是错误的。  
不过java中类的成员有缺省值。如Default.java  
并且成员变量先被缺省赋值,然后再在构造器被赋值.  
  
重载函数时要注意函数签名不同即传入的函数参数的个数或参数的类型不同。OverLoading.java  
java中可以几个文件联编。  
  
float类型共输出9位。  
  
超越是函数签名,返回值,参数列表均相同.  
超载是参数列表不同.  

```java
Super officer = new Sub("dd",1);/////这是使用的引用是子类被超类引用.  
officer.setSalary(333333.3432f);  
officer.show(); //////这里服从sub类中的show().  
Super manager = new Super("cc",2);  
manager.setSalary(900000.3432f);  
manager.show();  /////这里服从super类.  

```  
  
上面代碼为多态.  
  
无变元构造器这样定义:  
```java
public class Waterbird  
{  
    float weight;  
    Waterbird()  
    {  
    }/////////不能用Waterbird();  
}

当一个类有构造器并且有子类时两种方法:
一是它有无变元构造器.
二是它的子类有这样的结构:

1
2
3
4
类名(参数)  
{  
super(参数);////////超类中的构造器.  
}

当超类为虚拟类时,特别它含有非构造函数的虚拟方法.
如果调用子类并将其实例化.其内部构造的顺序是:

  1. 先声明成员变量,再调用超类的构造函数.如果此时超类的构造函数调用虚拟的方法.
  2. 那么这个虚拟的方法将下传至子类.如果此时子类超越了此虚拟方法并调用了成员变量,
  3. 那么这个成员变量将是缺省赋值.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

abstract class SupConstruction  
{  
    SupConstruction()  
    {  
        System.out.println("SupConstruction constructed!");  
        con();  
        System.out.println("con");  
    }  
    abstract void con();//虚拟函数  
}  
public class Construction extends SupConstruction//继承虚拟类  
{  
    int i =9;  
    Construction()  
    {  
        super(); //调用构造函数  
        System.out.println("Construction constructed");  
    }  
    public void con()//超越虚拟方法  
    {  
        System.out.println("Con "+i);  
    }  
    public static void main(String [] args)  
    {  
        Construction c = new Construction();//实例化.  
    }  
}

顺序是:

  1. 子类成员变量声明并缺省赋值
  2. 进入子类构造函数
  3. 超类构造函数调用
  4. 超类虚拟方法下传
  5. 子类成员变量赋值.