Java类的定义与使用详解

（本文总结自：疯狂Java讲义）
类可以被认为是一种自定义的数据类型，类是引用类型，使用类定义的变量都是引用变量。

类：某一类对象的统称，是一个概念性的东西；
对象：现实中具体的东西；

Java支持面向对象的三大特征：封装、继承、多态。
——使用访问修饰符来实现封装：private、protected、public
——使用关键字extends来实现子类继承父类

Java类的三句口诀：定义类、创建对象、调用方法

步骤一：定义类

[修饰符] class 类名
{
//成员变量（field）
//方法（method）
//构造器（constructor）
//内部类
//初始化块
} ——类体

–修饰符：有且仅有public、final | abstract（即：后二者不共存，public可与后面任一个共存）

–类名：语法上要求，只要是标识符即可（数字、字符、下划线、$，数字不开头）
专业上要求：多个单词的组合，每个单词首字母大写，eg: ArraysTest

public final class Person
{
	
}

(cmd运行方法：java Person)

编译可通过！（由于没有main方法，故而不能运行，只能编译）

（1）定义成员变量（field）——定义在类里的
[修饰符] 类型 变量名 [=初始值]；

-[修饰符]： private|protected|public、final、static（修饰符可有可无）

-类型：任意基本类型（8个）或引用类型（int[ ]）

-变量名：（驼峰写法camerlize：首字母小写，后面每个单词的首字母大写，eg:myHairColor）
成员变量用于描述该类/对象的状态（身高、年龄等），用名词

public class Role
{
	String name;
	int id;
	int[ ] qx;//数组类型
}

【注意】：

public class Role
{
	int age=25;//成员变量定义
	double a;//成员变量定义
	a=3.4;//赋值语句（错误）
	
}

类体里只能有上述五大成员类型，成员变量定义是对的，但是赋值语句不包括在内，故而是错的！
（2）定义方法（method）：

[修饰符] 返回值类型 方法名（形参列表）
{
//代码：定义变量（含数组变量）、变量赋值、流程控制、输出语句
如果声明了返回值类型，必须有return语句
} ——方法体

-[修饰符]：private | protected | public、final | abstract、static

-类型：任意基本类型或引用类型。

-返回值类型：可使用void声明没有返回值

-方法名：同成员变量
方法是用于描述类或对象的行为的，建议用动词。
eg：猪八戒.吃（西瓜）

-方法名：如 main、add等

-(形参列表)：(形参类型1 形参名1, 形参类型2 形参名2,…) 可有多个形参
eg:

public class  HelloWorld
{
//     修饰符    返回值类型  方法名    形参列表	
	public static   void      main  (String[] args) 
	{
		System.out.println("Hello World!");
	}
}

（3）定义构造器（constructor）

作用：用new来调用构造器来创建对象。
【如果没有为类写构造器，系统会默认为该类提供一个无参数的构造器。】

[修饰符] 构造器名（形参列表）
{
//代码
} ——构造器体

-修饰符：private | protected | public

-构造器名必须与类名相同

判断构造器，一看构造器名，二看是否有返回值

定义类
//  修饰符  class  类名
public final class User
{

//（1）成员变量
// (修饰符)	 类型 变量名 [=初始值]
	private String name;//定义成员变量
	int age;//成员变量，修饰符可有可无。
	double salary = 3500;//有初始化值的成员变量
	int[] qx;//数组类型成员变量
    public boolean isMarried;


//常量：一旦赋值永不改变。**所有字母大写**，单词间用下划线分割
	static int MAX_SIZE=200;


//定义方法
//[修饰符] 返回值类型 方法名（形参列表）
	public   void      walk()//形参列表可为空，即调用时不需要传入参数
	{
		System.out.println("在走路");
	}
	//一个String形参
	public void eat(String food)
	{
		System.out.println("正在吃："+food);
	}
    //两个int形参，返回值类型为int
	public static int add(int a , int b)
	{
		System.out.println("加法");
		return a+b;//返回值
	}


//构造器
// [修饰符] 构造器名(形参列表)
	public    User(String n)//构造器名必须与类名相同
	{
		System.out.println("创建User对象");
	}
}

步骤二：使用类（可以运行，有main方法）

类的四大作用（有且仅有）：
1）定义变量（所以的类都是引用类型）
定义的User类为引用类型，故而类可以用于声明变量
2）调用有static修饰的方法或有static修饰的变量
3）创建对象：new 构造器（参数）
4）派生子类

（1）定义变量
虽然类里头没有main方法，但是可以用类来声明变量，再运行
User u;
定义的类编译后生成的.class文件可以被同一目录下的程序所加载

public class  UserTest
{
	public static void main(String[ ] args) 
	{
		User u;//自定义的引用类型,
	}
}

（2）调用有static修饰的方法和有static修饰的变量：

System.out.println(User.add(4 , 12));

add方法是static修饰的，引用add方法有返回值int，故而可以输出方法的值，4和12都是形参列表。

System.out.println(User.MAX_SIZE);//调用static修饰的变量

编译、运行得到：200；

（3）创建对象
new 构造器（参数）

对象的作用：
1）调用：无static修饰的成员变量
2）调用：无static修饰的方法

&& 无static修饰的方法

User u1 = new User("abc");//创建对象，必须要传入参数，因为**定义构造器的时候有参数**，随意定
u1.eat("盐水鸭");//调用方法

假如定义一个没有参数的构造器：

public class Role 
{
	public Role()//构造器
	{
		
	}
}

则可以不传入参数：

      Role u2 = new Role();

&& 无static修饰的成员变量

//调用无static修饰的成员变量
		User a = new User("sdf"); //创建对象
        System.out.println(a.age);//调用成员变量

使用类四大作用的所有程序：

import java.util.Random;//导包

public class  UserTest
{
	public static void main(String[] args) 
	{
//作用一：定义变量		
		User u;//自定义的引用类型,
	
//作用二：调用有static修饰的方法和static修饰的变量：
	//只要定义的类的.class文件与本文件在同一个目录里，就可以加载到这个类
	    System.out.println(User.add(34,-22));

        Random rnd = new Random();//创建实例（对象）
        int res = User.add(-34,rnd.nextInt(40)*2);//参数不一定是具体的int值
		System.out.println(res);
        System.out.println(User.MAX_SIZE);

//作用三：创建对象————new 构造器（参数）
		User u1 = new User("abc");//创建对象，User构造器有参数
        User u2 = new User("def");
  //调用无static修饰的方法
		u1.eat("盐水鸭");//调用对象, eat有形参
        u2.walk();//walk方法无参数，故而无需写参数
		
		Role u3 = new Role();//Role构造器无参数

   //调用无static修饰的成员变量
		User a = new User("sdf"); 
        System.out.println(a.age);
	}
}