java类的结构（属性、方法、构造函数）

时间 2019-11-09

标签 java 结构属性方法构造函数栏目 Java 繁體版

原文原文链接

1、类的定义形式
类定义的通常形式以下java

[类定义修饰符] class <类名> 编程

{ //类体安全

[成员变量声明] [构造函数]网络

[成员方法]多线程

}函数

前面说过，在描述java语法时，方括号中的内容都是能够省略掉的。实际上任何程序设计相关语法都是如此，这是国际通行的标准。那么，要定义一个最简单的类就是以下的写法：
class Test
{

}
这个类由于类体没有包含任何内容，因此什么也不干，同时若是直接调试该程序，能够编译，可是运行错误，提示错误信息以下：“错误: 在类 Test 中找不到主方法, 请将主方法定义为: public static void main(String[] args)”。
为何会出现这个错误呢？由于讲过前面，一个java程序或者说一个java项目，必须有一个主类（主类内容接下来会讲），主类必须有一个主方法，主方法就是程序的入口，即程序首先是从主类的主方法中开始运行的，因此运行该程序天然会提出错误信息。
2、类的定义解释
一、类的定义：类的定义经过关键字class来实现，所定义的类名应符合标识符的规定。类的名字必须由大写字母开头而单词中的其余字母均为小写；若是类名称由多个单词组成，则每一个单词的首字母均应为大写例如TestPage；若是类名称中包含单词缩写，则这个所写词的每一个字母均应大写，如：XMLExample。还有一点命名技巧就是因为类是设计用来表明对象的，因此在命名类时应尽可能选择名词。
二、类定义修饰符修饰符:修饰符能够省略，也能够是public, protected, private, static, final，其中public、protected , private三个最多只能出现其中之一，能够与static, finaf组合起来修饰属性。

三、成员变量声明

成员变量是类的属性，声明的通常格式为：
[变量修饰符] <成员变量类型> <成员变量名>优化

变量修饰符:public、protected、private、和默认（frieddlly）。四、构造函数通常咱们讲的“函数”就是“方法”，构造函数是一个特殊的函数，虽然在类定义的过程当中用方括号括起来，即咱们能够不写构造函数，可是java系统会默认自动为每一个类生成一个缺省的不带任何参数的构造函数，在建立对象时系统会调用缺省的构造函数。若是程序中定义了构造函数，系统将再也不提供该缺省的构造函数。构造函数具备以下特色：（1）构造方法的方法名必须与类名相同，其它方法不能和类名相同。this

　　（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。spa

　　（3）构造方法的主要做用是完成对象的初始化工做，它可以把定义对象时的参数传给对象的域。线程

　　（4）构造方法不能由编程人员调用，而由系统调用。

　　（5）一个类能够定义多个构造方法，若是在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。

　　（6）构造方法能够重载，以参数的个数，类型，或排列顺序区分。
使用无参数构造函数的例子

class Test {
	String name;
	Test(){
		name="韦小宝";
	}
	public static void main(String[] args){
		Test t1=new Test();
		System.out.println(t1.name);
		t1.name="康熙";
		System.out.println(t1.name);
	}
}

执行程序，输出结果以下：韦小宝康熙在程序中并无对对象 t1的name变量进行赋值，而打印输出 t1.name 输出结果是“韦小宝”，此时Test类的构造函数中对name变量进行了初始化，输出的就是初始化的值；而对t1对象的name属性进行了赋值后，此时输出结果就是从新赋值后的值，即“康熙”。使用有参数构造函数的例子

class Test {
	String name;
	Test(){
		name="韦小宝";
	}
	Test(String myName){
		this.name=myName;
	}
	public static void main(String[] args){
		Test t1=new Test();
		System.out.println(t1.name);
		Test t2=new Test("康熙");
		System.out.println(t2.name);
	}
}

执行程序，输出结果以下：韦小宝康熙

五、成员方法成员方法定义的类的操做和行为，通常形式为：
[方法修饰符] <方法返回值类型> <方法名>（[<参数列表>]）
{
方法体
}
成员方法修饰符主要有public、private、protected、final、static、abstract和synchronized七种，前三种的访问权限、说明形式和含义与成员变量一致。
与成员变量相似，成员方法也分为实例方法和类方法。若是方法定义中使用了static ,则该方法为类方法。public static void main(String [] args)就是一个典型的类方法

3、类的修饰符及其访问范围
前面说了修饰符，可是没有提及含义，这里讲解一下常见的类访问修饰符：

可见度	public	protected	private	缺省
同一类中可见	是	是	是	是
同一包中对子类可见	是	是	否	是
同一包中对非子类可见	是	是	否	是
不一样包中对子类可见	是	是	否	否
不一样包中对非子类可见	是	否	否	否

关于包、子类概念以后讲解。

Java程序在定义类时，除了使用class关键字标识以外，还能够在class以前增长若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类。修饰符之间的前后排列次序对类的性质没有任何影响。

一）非访问修饰符。

1，  抽象类：
    凡是用abstract修饰符修饰的类被称为抽象类。抽象类就是没有具体对象的概念类。
    抽象类是一种通过优化的概念组织方式：把共同特色抽象出来；其后在描述和处理某一种具体对象时，就只需描述不一样的特殊之处。这种组织方式使得全部的概念井井有条，简洁洗练，很是符合人们平常的思惟习惯。
    因为抽象类是它的全部子类的公共属性的集合，因此使用抽象类的一个优势就是能够充分利用这些公共属性来提升开发和维护程序的效率。
    值得一提的是，面向对象技术是要用更接近于人类思惟方式的方法来处理实际问题，抽象类的设立就是这种思想的具体体现之一，它是模仿人类的思惟模式的产物。

2，最终类：
    若是一个类被final修饰符所修饰和限定，说明这个类不可能有子类。
    被定义为final的类一般是一些有固定做用、用来完成某种标准功能的类。如Java系统定义好的用来实现网络功能的InterAddress、Socket等类都是final类。
       abstract和final修饰符不能同时修饰一个类，由于abstract类自身没有具体对象，须要派生出子类后在建立子类的对象；而final类不可能有子类。这样放在一块儿修饰就没有意义了。

3，有些类的修饰符也能够用来修饰类中的域或方法：

(1) 域：是类和对象的静态属性，定义域的操做就是说明变量或建立对象的操做。

<1> 静态域：
用static修饰符修饰的域是仅属于类的静态域。静态域是类中每一个对象共享的域。他们是类的域，不属于任何一个类的具体对象。是一个公共的存储单元，任何一个类的对象访问它时，取到的都是相同的数值。

<2> 静态初始化器：
    静态初始化器是由关键字static引导的一对大括号括起的语句组。做用是：在加载时，初始化类的静态域。
    与构造函数相同，他们都是用来完成初始化的工做，可是静态初始化器与构造函数有三点不一样：
        ①构造函数是对每一个新建立的对象初始化，而静态初始化器是对类自身进行初始化。
     ②构造函数是在用new运算符产生新对象时由系统自动执行，而静态初始化器则是在它所属的类加载到内存时由系统调用执行。
     ③不一样于构造函数，静态初始化器不是方法，没有方法名、返回值和参数列表。

<3> 最终域：
    用final修饰的域，实际上就是Java中的常量。
    用final修饰符说明常量时，须要注意如下几点：
    ①须要说明常量的数据类型。
    ②须要同时指出常量的具体取值。
    ③由于全部类对象的常量成员，其数值都固定一致，为了节省空间，常量一般声明为static。

<4> 易失域：
若是一个域被volatile修饰符所修饰，说明这个域可能同时被几个线程所控制和修改，即这个域不只仅被当前程序所掌握，在运行过程当中可能在其余未知的程序操做影响和改变该域的取值。在使用当中应该特别注意。
一般，volatile用来修饰接受外部输入的域。如表示当前时间的变量将系统的后台线程随时修改，以保证程序中取到的老是最新的当前系统时间，因此能够把它定义为易失域。

(2)方法：是类的动态属性，标志了类所具备的功能和操做。小括号是方法的标志。

<1> 抽象方法：
修饰符abstract修饰的抽象方法是一种仅有方法头，而没有具体的方法体和操做实现的方法。使用抽象方法的目的是使全部的子类，对外都呈现一个相同名字的方法，是一个统一的接口。全部的抽象方法，都必须存在于抽象类之中。

<2> 静态方法：
用static修饰符修饰的方法，是属于整个类的类方法，不用的是对象或实例的方法。调用这种方法时，应该使用类名做前缀；这种方法在内存中的代码段将随着类的定义而分配和装载，不被任何一个对象专有；只能处理属于整个类的成员变量。

<3> 最终方法：
用final修饰符修饰的类方法。功能和内部语句不能再更改的方法，不能再被继承。
注意：全部已被private修饰符限定为私有的方法，以及全部包含在final类中的方法，都被缺省地认为是final的。

<4> 本地方法：
用native修饰符声明其余语言书写方法体并具体实现方法功能的特殊的方法。这里的其余语言包括C/C++/FROTRAN/汇编等。因为native的方法的方法体使用其余语言在程序外部写成，因此全部的native方法都没有方法体，而用一个分号代替。

<5> 同步方法：
若是synchronized修饰的方法是一个类的方法（即static的方法），那么在被调用执行前，将把系统类Class中对应当前类的对象加锁。若是synchronized修饰的是一个对象的方法（未用static修饰的方法），则这个方法在被调用执行前，将把当前对象加锁。Synchronized修饰符主要用于多线程共存的程序中的协调和同步。

二）访问控制符。
访问控制符是一组限定类、域或方法是否能够被程序里的其余部分访问和调用的修饰符。类的访问控制符只有一个public，域和方法的访问控制符有四个，分别是public、private、protected、private protected，另外还有一种没有定义专门的访问控制符的缺省状况。

1，  公有访问控制符public：
      Java的类是经过包的概念来组织的，包氏类的一个松散的集合。处于同一个包中的类能够不须要任何说明而方便的互相访问和引用，而对于不一样包中的类，则不行。但当一个类被声明为public时，他就具备了被其余包中的类访问的可能性，只要这些其余包中的类在程序中使用import语句引入public类，就能够访问和引用这个类。
    类中被设定为public的方法是这个类对外的接口部分，避免了程序的其余部分直接去操做类内的数据，这实际就是数据封装思想的体现。
    每一个Java程序的主类都必须是public类，也是基于相同的缘由。
    用public修饰的类的域称为公共域。若是公共域属于公共类，则它能被全部的其余类所引用。public修饰符会形成安全性的数据封装性降低，因此通常应减小public域的使用。

2，缺省访问控制符：
    缺省访问控制权规定，该类只能被同一个包中的类访问和引用，而不能够被其余包中的类使用，这种访问特性又称为包访问性。
    一样道理，类内的域或方法若是美育访问控制符来限定，也就具备包访问性。
    简单说，定义在同一个程序中的全部类属于一个包。

3，私有访问控制符private :
用private修饰得域或方法只能被该类自身所访问和修改，并且不能被任何其余类（包括该类的子类）来获取和引用。private修饰符用来声明那些类的私有成员，它提供了最高的保护级别。

4，保护访问控制符protected :
用protected修饰的成员变量能够被三种类所引用：该类自身、与它在同一个包中的其它类、在其余包中的该类的子类。使用protected修饰符的主要做用是容许其余包中该类的子类来访问父类的特定属性。

5，私有保护访问控制符 private protected :
用private protected修饰的成员变量能够被两种类访问和引用，一种是该类自己，一种是该类的全部子类。把同一个包内的非子类排除在可访问的范围以外，使得成员变量更专于具备明确继承关系的类，而不是松散地组合在一块儿的包。

class Animal {
  String name;
  int age;
  Animal(){
   name="Dog";
   age=3;
  }
  Animal(String name,int age){
   this.name=name;
   this.age=age;
   }
}
public class AnimalDemo{
  public static void main(String args[]){
   Animal a=new Animal();
   Animal b=new Animal("cat",5);
   System.out.println(a.name+" is "+a.age+" years old");
   System.out.println(b.name+" is "+b.age+" years old");
  }
}

4、类的加载机制：

一、在虚拟机的生命周期中一个类只被加裁一次
二、加载的原则是：延迟加载
三、类加载的时机
1）当第一次建立对象时要加载
2）调用static方法时要加裁，访问static属性时要加裁，调用static代码块时要加载
3）当加载子类时会先加裁父类
4）建立对象引用时不加裁类
5）子类调用父类的static方法时会加裁
在这里要注意的是：当子类没有重写父类的static方法时，只加裁父类不加裁子类。当子类重写了父类的静态方法时既加裁父类又加裁子类。
6）访问static常量时，若是编译器在以计算出常量的值能够不加裁类，不然会加裁。
7）用Class.forName(类名)来显示的加载一个类

5、java编程多个类的程序运行。

在一个*.java的文件中，只能有一个public class的声明，可是容许有多个class的声明，即一个源文件（*.java）中只能有一个公共类，能够有若干默认类。举例：

class   Animal {   
  String   name;   
  int   age;   
  Animal(){
    name="Dog";
    age=3;
  }
  Animal(String name,int age){
    	this.name=name;
    	this.age=age;
    }
}
public class AnimalDemo{
  public static void main(String args[]){
    Animal  a=new Animal();
    Animal  b=new Animal("cat",5);
    System.out.println(a.name+" is "+a.age+" years  old");
    System.out.println(b.name+" is "+b.age+" years  old");
  }
}

程序执行结果：Dog is 3 years old
cat is 5 years old

本例中AnimalDemo.java源文件中有两个类：Animal类 和 AnimalDemo类，AnimalDemo类做为公共类，也就是主类，该类中有主方法；默认类（Default类）Animal类定义了两个构造方法，没有主方法，程序编译时生成两个
 字节码文件，分别是Animal.class 和 AnimalDemo.class。在AnimalDemo类中调用了
 Animal类实例化对象，并进行相应的数据处理。注意当一个源文件中有多个类的时候，使用主类做为 文件名。
一样，咱们能够将一个源文件中的多个类分解成多个源文件，即一个类为一个源文件。好比上面的例子。源文件：Animal.java

class   Animal {   
  String   name;   
  int   age;   
  Animal(){
    name="Dog";
    age=3;
  }
  Animal(String name,int age){
    	this.name=name;
    	this.age=age;
    }
}



源文件：AnimalDemo.java

public class AnimalDemo{
  public static void main(String args[]){
    Animal  a=new Animal();
    Animal  b=new Animal("cat",5);
    System.out.println(a.name+" is "+a.age+" years  old");
    System.out.println(b.name+" is "+b.age+" years  old");
  }
}

在命令提示符下，执行下面三个步骤：一、编译Animal.java文件（javacAnimal.java）二、编译AnimalDemo.java文件（javacAnimalDemo.java）三、执行AnimalDemo.javae文件 （javaAnimalDemo）。 也能够直接编译运行AnimalDemo文件，即直接从上面第二个步骤执行，当程序编译AnimalDemo源文件时，遇到 Animal  a=new Animal()语句时，会自动编译Animal源文件。java程序中，就是由这样的类组成个应用程序，在编写过程当中，通常采用 一个类一个源文件的方式进行编程，一遍对类进行维护和修改。