【java】关于java类和对象，你想知道的在这里！

java类的基本组成

java作为一门面向对象的语言， 类和对象是最重要的概念之一，下面，就让我们来看看java中类的基本结构是怎样的：

 

一个简单的java类主要可由以下几个部分（要素）组成：

1.实例变量

2.构造函数 

3.更改器方法

4.访问器方法

 

例如：

class Myclass {
   field1...  // 声明实例变量（实例域）
   field2...  // 声明实例变量（实例域）
   constructor..   // 构造函数
   getMethod1..  // 访问器方法1
   getMethod2..   // 访问器方法2
   setMethod1...  // 更改器方法1
   setMethod2...  // 更改器方法2
}

也许你对java类的运用早已了熟于心了，但对结构的细化和分析有助于你进一步的了解

让我们看一下下面这个实例

 

Myclass.java:

public class Myclass {
     private String name;  // 声明实例变量（实例域）
     public Myclass () {   // 构造函数
       name = "尚无名字";
     }
     public String getName () {   // 访问器方法
       return name;
     }
     public void setName (String str) {  // 更改器方法
       name = str;
     }
}

Test.java:

public class Test {
   public static void main(String args []) {
     Myclass instance = new Myclass();
     System.out.println(instance.getName());  // 输 出当前的实例变量name的值
     instance.setName("彭湖湾");    // 修改name的值
     System.out.println(instance.getName()); // 再次输 出实例变量name的值
   }
}

结果：

尚无名字
彭湖湾

 

关于构造函数有几点要注意：

1. 构造函数和类同名

2. 它没有返回值

3. 可以有多个构造函数，允许实现构造函数重载（下面会讲）

 

【注意】没有返回值意味着你不能在构造函数里写return XXX,或者是为方法加上类型如public String Myclass() （具体点说，如果你在构造器里面return一个值会直接导致报错error,而如果你通过public String Myclass的方式加上类型，那么这就不再是个构造函数，而是个普通方法）

函数重载

函数重载： 对类中的一组同名函数， 根据函数实参的参数类型和参数个数的不同，决定调用哪一个对应的函数，这个过程，叫做函数的重载：

 

根据参数类型不同进行重载

people.java:

public class People {
   public  void print (String str) {
     System.out.println("我调用了参数类型为String的方法！");
     System.out.println(str);
   }
   public  void print (int number) {
     System.out.println("我调用了参数类型为int的方法！");
     System.out.println(number);
   }
}

 

Test.java:

public class Test {
   public static void main(String args []) {
     People people1 = new People();
     people1.print("字符串");
   }
}

输出：

我调用了参数类型为String的方法！
字符串

如果将Test.java中的语句换成：

People people1 = new People();
people1.print();

结果

我调用了参数类型为int的方法！

根据参数个数不同进行重载

People.java:

public class People {
   public  void print (String str) {
     System.out.println("我调用了一个参数的方法！");
   }
   public  void print (String str1, String str2) {
     System.out.println("我调用了两个参数的方法！");
   }
}

Test.java:

public class Test {
   public static void main(String args []) {
     People people1 = new People();
     people1.print("参数1", "参数2");
   }
}

输出：

我调用了两个参数的方法！

如果将Test.java中的语句换成：

public static void main(String args []) {
   People people1 = new People();
   people1.print("参数");
}

输出：

我调用了一个参数的方法！

 

【注意】函数重载只和参数类型和参数个数有关，和返回值类型无关！！ 例如public void XXX()和public String XXX()不构成重载！ （这也当然会报错，因为两个函数重复了）同时重载也和参数的命名无关， public void XXX(String str1)和 public void XXX(String str2)是同一个函数，这和函数重载就更没有毛线关系了

 

构造函数重载

 

和函数重载的特性一致，但有一个有趣的一点要注意： 当你没有写入构造函数的时候，系统会默认提供一个无参的构造函数给你， 所以就算没有显式地写type 实例 = new type()也是成立的

 

但是！ 当你写了一个有参数的构造函数，但又没有写无参数的构造函数时，type 实例 = new type()就会报错了！（因为默认的无参构造函数已经被你写的有参数的构造函数给取代了嘛~~~~）

 

 

实例变量的默认值，和初始化实例变量

 

如果你声明了一个实例变量，但没有初始化它，那么这个变量会取得一个默认值，默认值依类型决定：

这是每个基本类型对应的默认值

boolean        false
char              '/uoooo'(null)
byte              (byte)
short             (short)
int                 
long                （L）
float               0.0 （f）
double           0.0 （d）

 

对于引用类型，一律初始化为null

 

例子：

Default.java:

public class Default {
   private  int number;
   private float f;
   private boolean bool;
   private char c;
   private byte b;
   public void printDefaultValues () {
     System.out.println("int的默认值:" + number);
     System.out.println("float的默认值:" + f);
     System.out.println("boolean的默认值:" + bool);
     System.out.println("char的默认值:" + c);
     System.out.println("byte的默认值:" + b);
   }
}

 

Test.java:

public class Test {
   public static void main(String args []) {
     Default default1 = new Default();
     default1.printDefaultValues();
   }
}

输出

int的默认值:
float的默认值:0.0
boolean的默认值:false
char的默认值:

一般情况下，最好对一个实例变量进行初始化，去覆盖掉默认值

public class Default {
   private  int number = ;
}

访问私有实例变量

私有变量的访问方式我分成两种： 类内访问和实例访问

（实际上两者概念上有交叉，但为了方便说明我将两者分开了）

 

类内访问：在定义一个类的时候，在类内部访问私有变量

实例访问： 创建对应类的一个对象，通过对象访问

 

实例访问

创建的对象不能直接访问私有实例变量，但能通过公有的访问器方法访问：

例如：

 

People.java:

public class People {
   private String name;
   public People (String aName) {
     name = aName;
   }
   public String getName () {
     return name;
   }
}

在Test.java中，如果我们试图直接通过People的实例对象访问name私有变量：

public class Test {
   public static void main(String args []) {
     People people1 = new People("彭湖湾");
     System.out.println(people1.name);  // 直接通过People的实例对象访问name私有变量
   }
}

编译器会友好地提示：The field People.name is not visible，并在运行时候报error，这告诉我们不能不能通过people1.name直接访问私有实例变量name

 

但我们的访问器方法getName是定义为public的呀，所以我们能通过getName方法访问

public class Test {
   public static void main(String args []) {
     People people1 = new People("彭湖湾");
     System.out.println(people1.getName());   
   }
}

运行后输出：

彭湖湾

私有的变量对于类实例来说本是“不可见”的，但公有的访问器方法却有权让它暴露出来。

 

类内访问

在类定义的代码里，我们可以自由地访问私有实例变量，不过有一点要注意： 私有实例变量的最高访问权限是类，而不仅仅是单个对象（也就是说同一个类定义的不同的对象能够对各自的私有实例变量“互访”）

 

例如，在下我们通过 equalName方法判断People类的两个实例对象的name变量值是否相等

public class People {
   private String name;
   public People (String aName) {
     name = aName;
   }
   public boolean equalName (People other) {
     String otherName = other.name; // 访问另一个对象的私有的name变量
     return name.equals(otherName);
   }
}

在Test.java中：

public class Test {
   public static void main(String args []) {
     People people1 = new People("彭湖湾");
     People people2 = new People("XXX");
     People people3 = new People("彭湖湾");
     System.out.println(people1.equalName(people2));
     System.out.println(people1.equalName(people3));
   }
}

输出结果：

false   // 说明people1和people2的name值不相等
true    // 说明people1和people3的name值相等

在equalName方法中，我们在方法参数中声明了同一个people类的另外一个实例对象other，并通过other.name直接取得它的私有实例变量并在方法中使用。运行是成功的，这意为着私有实例变量并不是为单个对象“所私有”，而是为整个类所“私有”。 这个类下的所有对象，都拥有对同一类下某个对象的私有实例变量的直接的访问权限

 

当然，不同类的对象， 就没有这种直接的访问权限了

 

实例变量和局部变量“交锋”

在方法中， 可以直接通过名称访问实例变量（隐式访问），也可以通过this去显式访问

 

事实上，以下两种方式效果是相同的

public class People {
   private String name;
   public People (String aName) {
     name = aName; // 隐式访问实例变量
   }
}

public class People {
   private String name;
   public People (String aName) {
     this.name = aName;   // 显式访问实例变量
   }
}

 

当局部变量和实例变量同名的时候，局部变量会覆盖同名的实例变量，让我们看一个例子：

public class People {
   private String name ="实例name变量";
   public People (String name) {
     System.out.println("输出：" + name);  //在构造函数中这样做有些怪异，但为了展示请不要介意
   }
}

在People类中，有一个实例变量name, 同时在构造函数中将通过参数的形式引入一个同名的局部变量

name,这个时候，我们通过name访问到的是局部变量name，而不是隐式访问的实例变量name:

 

请看Test.java中的测试：

public class Test {
   public static void main(String args []) {
     People people1 = new People("局部name变量");
   }
}

运行后打印 

输出：局部name变量

打印的是“局部name变量”而不是"实例name变量"， 这代表， 同名的局部变量覆盖了对应的实例变量

 

嗯嗯，正因如此就会产生一些问题了：我们可能常常希望能够在构造函数中通过参数引入的局部变量的值初始化实例变量，但因为同名覆盖的问题却会带来一些烦恼：

// 无效的写法！
public class People {
   private String name
   public People (String name) {
     name = name; // 两个都取局部变量this，当然无效了
   }
}

解决办法有两种：

 

1. 为局部变量取另外一个名称（为了语意的理解可以在同名变量前加上一个字母）

public class People {
   private String name
   public People (String aName) {
     name = aName;
   }
}

2. 使用this显式访问实例变量，这样就可以“绕过”局部变量的覆盖

public class People {
   private String name;
   public People (String name) {
     this.name = name;
   }
   public String getName () {
     return this.name;
   }
}

小小地总结一下这一小节：

 

1. 在方法中， 可以直接通过名称访问实例变量（隐式访问），也可以通过this去显式访问实例变量

2. 当局部变量和实例变量同名的时候，局部变量会覆盖同名的实例变量

3.  对2中造成的冲突问题，可从两个方向解决：

  3.1 为局部变量取另外一个名称

  3.2  使用this显式访问实例变量

 

静态变量和静态方法

当对一个实例变量加以static修饰符的时候，它就变成了一个静态变量。（“静态”这个词可能并不太能让你推测出它的意义和用法）

例如：

 

public static int  peopleTotal = ; // 这里设为public只是为了演示

静态变量是隶属于类的，而不是隶属于对象，也就是说，静态变量和实例变量是恰好对立的两种变量，前者属于类，后者属于类创建的实例对象。

 

对于实例变量：每创建一个对象，就会创建一份类内所有实例变量的拷贝

对于静态变量： 无论创建多少个对象， 静态变量从始至终都只有一份，为所有对象“共享”

 

示例(访问静态变量)：

People.java:

public class People {
   private String name;
   public static int  peopleTotal = ; // 这里设为public只是为了演示
   public People (String name) {
     this.name = name;
     peopleTotal++; // 每次调用构造函数时候，使得类的peopleTotal静态变量加1
   }
}

Test.java:

public class Test {
   public static void main(String args []) {
         // 创建三个People对象
     People people1 = new People("one");
     People people2 = new People("tow");
     People people3 = new People("three");
     System.out.print(People.peopleTotal); // 输出此时的peopleTotal
   }
}

 

结果： 输出3

 

 

我们需要注意两点

第一点，我们最终是通过People.peopleTotal去访问的peopleTotal， 这进一步证明了它是属于类的，而不属于对象

第二点，最后结果输出了3， 这说明：peopleTotal静态变量“从始至终都只有一个”， 连续的三次实例化而调用的构造函数， 使它经历了从0到1,1到2和2到3的过程（反之，如果peopeTotal是实例变量，那么因为每个对象都对这个有个拷贝，则最终输出的应该是1（0+1=1））

 

通过静态方法访问静态变量

如果一个方法仅仅用到静态变量的话，那么这个方法应该作为一个静态方法使用而不是实例方法，也就是说， 它要加上static修饰符，例如：

 

public static int getPeopleTotal

让我们对上述的例子稍加改造：

People.java

public class People {
   private String name;
   private static int  peopleTotal = ; // 和上面的例子不同，这里的静态变量是私有的
   public People (String name) {
     this.name = name;
     peopleTotal++; // 每次调用构造函数时候，使得类的peopleTotal静态变量加1
   }
   public static int getPeopleTotal () {
     return peopleTotal; // 通过静态方法访问私有静态变量
   }
}

Test.java:

public class Test {
   public static void main(String args []) {
     People people1 = new People("one");
     People people2 = new People("tow");
     People people3 = new People("three");
     System.out.print(People.getPeopleTotal()); // 输出peopleTotal
   }
}

 

结果 输出3

 

静态方法的各种性质和静态变量类似，它也是隶属于类而不是对象

 

上面我们都在强调一点，静态变量， 静态方法隶属于类而不是对象，那么你可能会因此问几个问题：

 

1.对象能够访问静态变量和静态方法吗？ （静态变量/方法是否一定要由类调用？）

2.类内定义的实例方法能访问静态变量吗？ （类内的静态变量是否一定要由静态方法调用？）

 

下面我将对这两个问题一一解答：

对象能够访问静态变量和静态方法吗？

可以！

实际上，你可以用对象访问静态变量或方法，但你最好不要这样做，因为这容易造成混淆，具体一点说是混淆我们对“静态”的认知，实际上和对象毫无关系的静态变量用对象来调用，会造成我们在理解上的一种矛盾，这降低了程序的可读性。 用类名调用静态方法才是建议的操作

 

// 虽然能达到相同效果但不要这么做！！
Test.java
public class Test {
   public static void main(String args []) {
     People people1 = new People("one");
     People people2 = new People("tow");
       People people3 = new People("three");
     System.out.print(people1.getPeopleTotal()); // 用people1对象调用了静态方法
   }
}

 

类内定义的实例方法能访问静态变量吗？

（类内的静态变量是否一定要由静态方法调用？）

可以！

答案当然是可以的，但请注意，如果一个方法仅仅只使用到静态变量（例如我们这个例子），那它应该作为一个静态方法，而不是实例方法，原因和上面相同，这容易混淆我们对于静态变量的认知

 

// 虽然能达到相同效果但不要这么做！！
People.java:
public class People {
   private String name;
   private static int  peopleTotal = ;
   public People (String name) {
   this.name = name;
   peopleTotal++; // 每次调用构造函数时候，使得类的peopleTotal静态变量加1
   }
   public  int getPeopleTotal () {
   return peopleTotal; // 通过实例方法访问私有静态变量
   }
}

Test.java:

public class Test {
   public static void main(String args []) {
     People people1 = new People("one");
     People people2 = new People("tow");
           People people3 = new People("three");
     System.out.print(people1.getPeopleTotal()); // 用people1对象调用了实例方法！！
   }
}

【注意】上面说法的前提“一个方法仅仅只使用到静态变量”，如果一个方法不仅仅用到静态变量，情况就不一样了

 

main方法

 

我想每一个写java的筒子们应该都很熟悉的一段代码是public static void main(String args []){ ....}

1.在Java中，main()方法是Java应用程序的入口方法

2. java规范要求必须写成public static void main(String 字符串 []){ ....}的形式

除了字符串数组名称可以任意取，static,void和参数一律不可缺少

 

例如我如果省略static就会导致这一段报错：

 

String args [] 的作用

 

这个字符串数组是用来接收命令行输入参数的，命令行的参数之间用空格隔开

例子：

public class TestMain {
    public static void main(String args[]){
        System.out.println("打印main方法中的输入参数！");
        for(int i=;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}

假设要执行的这个java文件的路径是D:\Study\basetest\src， 则：

D:\Study\basetest\src>javac TestMain.java
 
D:\Study\basetest\src>java TestMain
打印main方法中的输入参数！

[完]

 

参考资料：

《java核心技术 卷1》—— Cay S. Horstmann, Gary Cornell

《Java中的main()方法详解》 —— 熔岩   http://lavasoft.blog.51cto.com/62575/53263