一个类里都装了些什么

我们知道，类是Java的基本要素，一个Java程序就是由若干个不同的类组成的。关键字是class，格式为

class 类名{
	类体的内容
}

类体由两部分构成：

变量的声明和方法的定义

变量

格式：数据类型 变量名；
成员的变量类型可以是任何一种数据类型，基本类型如整型（short，int，long），浮点型（float，double），字符型（char），逻辑类型（boolean），引用类型如数组，对象和接口。

常量

关键字：final
如果成员变量和局部变量被关键字final修饰，那么该变量就是常量。程序在声明该常量时必须赋值，且在运行期间该值不再发生变化，否则程序将报错。

class Class{
	final int PI 3,1415926;//表示PI的值始终为3，1415926  
}

静态变量

关键字：static
当某个变量被static修饰后，它便被类所有而不被对象所有，当我们调用时可以用对象调用，也可以用类名直接调用，但通常情况下用类名调用，静态变量的值可以通过对象调用时被改写，举例如下：

public class My_Idol{
	//定义一个静态变量
	staitc String idol="李现";
	
	//主方法
		public static void main(String[] args){
		//创建两三个对象
		My_Idol shiye1=new My_Idol();
		My_Idol shiye2=new My_Idol();
		My_Idol shiye3=new My_Idol();
	//直接使用类名调用静态变量
		System.out.println("通过类名调用:"+My_idol.idol);
	//使用对象调用
		System.out.println("使用对象1调用:"+shiye1.idol);
		System.out.println("使用对象2调用:"+shiye2.idol);
	}  
}

程序运行结果为：

通过类名调用：李现
使用对象1调用：李现
使用对象2调用：李现

当我们用对象修改静态变量的值时：

public class My_Idol {
	
		//定义一个静态变量
		static String idol="李现";
		//主方法
			public static void main(String[] args){
				//创建两个对象
				My_Idol shiye1=new My_Idol();
				My_Idol shiye2=new My_Idol();
				//用对象二修改静态变量的值
				shiye2.idol="蒲熠星";
		//直接使用类名调用静态变量
			System.out.println("通过类名调用:"+My_Idol.idol);
		//使用对象调用
			System.out.println("使用对象1调用:"+shiye1.idol);
		//使用修改后的值调用
			System.out.println("修改后的值为:"+shiye2.idol);
		}  
	}

程序运行后的结果为：

*通过类名调用:蒲熠星
使用对象1调用:蒲熠星
修改后的值为:蒲熠星

通过两个例子我们可以看到，虽然创建了不同的对象，但是当他们调用静态变量后的结果却是一样的，并且当通过其中一个对象修改了静态变量的值后，其他对象调用的也是修改后的值，这说明静态变量在类里是唯一的，属于类而不属于对象，所以通常情况下我们直接用类名调用静态变量。

静态常量

格式：static final 数据类型 常量名=某个值

class{
	static final String idol="李现";
}

构造方法

构造方法是类中的一种特殊方法，只能在创建对象时被调用。构造方法的名字必须和类名相同，且没有类型。我们可以在类中编写若干构造方法，但这些方法的参数（个数，类型等）必须不同。如果没有编写，系统会默认一个构造方法，该方法无参数，且方法内无语句。举例如下：

public class My_Idol {
	//构造方法1
	My_Idol(String n){
		System.out.println("我的的爱豆是"+n);
	}
	//构造方法2
	My_Idol(int n){
		System.out.println("我有"+n+"个爱豆");
	}
	//主函数
	public static void main(String[] args) {
		//创建对象时直接调用构造方法
		My_Idol my1=new My_Idol("李现");
		My_Idol my2=new My_Idol(2);
		
	}
}

程序运行的结果为：

我的的爱豆是李现
我有2个爱豆

以上程序创建了两个构造方法，它们参数的数据类型不同（也叫方法重载），并且是在创建对象时直接调用的，也叫用构造器传参。

空返回值的方法和带返回值的方法

public class Add{
 //不带返回值的方法 
	  void Add1(int x,int y) {
		int z;
		z=x+y;
		System.out.println("x+y="+z);
	}
	  //带返回值的方法
	 int Add2(int x,int y){
		 int z;
		 z=x+y;
		 System.out.println("x+y="+z);
		 return z;
	  }
	//主函数
	public static void main(String[] args) {
		Add adds=new Add();
		adds.Add1(10, 20);
		adds.Add2(30, 40);
	}
	}

运行结果为：

x+y=30
x+y=70

final方法

当一个方法被final修饰时，是不允许子类在继承时对其进行重写的。

静态方法

静态方法和静态变量有相似之处。
静态方法属于类，可以直接用类名调用；
静态方法可以直接调用静态变量，如果要调用非静态变量，只能通过创建对象来实现；
静态方法也可以直接调用静态方法，如果要调用非静态方法，只能通过创建对象来调用。举例如下

public class Add {
	//定义一个静态变量和非静态变量
	 static int x=10;
	 int y=10;
	 //创建一个静态方法
	  static void Add1() {
		  //直接使用静态变量x
		System.out.println("x="+x);
		//必须先创建对象，然后再通过对象调用
		Add add=new Add();
		System.out.println("y="+add.y);
	}
	//主函数
	public static void main(String[] args) {
		//因为主函数也是一个静态函数，所以可以直接调用静态函数Add1
		Add.Add1();
	}
}

程序运行结果为：

x=10
y=10

代码块

普通代码块：

就是方法中的方法体

初始化代码块：

在创建对象时执行

静态代码块

只调用一次，在加载时执行
举例如下：

public class Add {
	{
		System.out.println("代码块");
	}
	static {
		System.out.println("静态代码块");
	}
	
	//主函数
	public static void main(String[] args) {
		Add a=new Add();
		Add b=new Add();
	}
}

运行结果：

静态代码块
代码块
代码块

我们可以发现，创建了几次对象，代码快就运行了几次，而静态代码块只运行了一次，并且是在创建对象前就被执行了。

主方法

主方法用得太多了，就不提了吧…

public static void main(String[] args){

}

一个类里还可以有很多组成，这里介绍了几种常见的，还有什么就等读者自己去发现吧~