目录
- 类的定义
- 对象的创建
- 方法的调用
- 变量的作用域
- this关键字
- static关键字
类的定义使用class关键字，具体结构如下：
格式：
[修饰符] class 类名
{
属性定义（声明）;//共有的特性
方法定义（声明）;//一系列动作
}
注：[ ]表示可以省略，一般情况下都不使用修饰符
修饰符的作用是用来限定类的使用方式。其中：
public：指明此类为公有类；
abstract：指明此类为抽象类；
final：指明此类为终结类。
在类的内部可以包含多个属性和方法。
例如：
class Employee {
//属性声明
String name;
int age;
double salary;
}
分析：
定义一个Employee类，声明name，age，salary属性。
类的属性描述一个类的特性，比如人的姓名、年纪、性别等。
属性声明的语法结构为：
[修饰符] 变量类型 变量名[=变量初始值];
注：[]表示可以省略
例如：
String name="lisi"; int age=18; double weight=142.2;
**一个类可以包含多个属性，也可以没有属性。**属性也可以有修饰符。
1.2 方法类的方法用来描述类的活动或动作，即一系列动作。
方法声明的语法结构为：
[修饰符] 返回值类型 方法名(参数列表){
//方法体
}
例如：
void raise(double p){//定义raise方法
salary=salary+p;
System.out.println(name + "涨工资之后的工资为：" + salary);
}
分析：
返回值类型为void，方法名为raise，包含一个double型参数。
构造方法是一种特殊的方法，利用构造方法能够初始化对象的数据，**构造方法必须与定义它的类有完全相同的名字。**构造方法在它定义类里面。
构造方法的结构如下：
[修饰符] 类名 (参数列表){
//方法体
}
例如：
class Employee {
String name;
int age;
double salary;
public Employee() {//不带参数的构造方法
name="小明";
age=32;
salary=12.2;
}
public Employee(String s,int a,double sa) {//带参数的构造方法
name=s;
age=a;
salary=sa;
}
}
分析：
定义一个Employee类，有name、age和salary属性，写出Employee构造方法。
构造方法和普通方法的区别如下：
作用不同。构造方法是为了创建一个类的实例。方法的作用是为了执行Java代码。
返回值不同。构造方法没有返回值，也不需要void。方法能返回任何类型的值或者无返回值。
注：
1 如果类里没有构造方法，系统默认有一个无参的什么也不会做的构造方法；
2 如果类里定义了有参的构造方法，则默认的无参的构造方法就不存在了；
3 构造方法是实例化对象才能调用，不能随意调用。
对象是类的实例，可以从一个类中创建许多实例（对象）。
类是抽象的，对象是具体的。
声明对象的语法结构如下：
类名 对象名;
例如：
Employee e1;
分析：
对象的声明并my创建对象，只是使对象成为该类的一个实例。
要为对象分配内存空间，需要创建对象，就要使用new关键字，创建对象的语法结构如下：
对象名 =new 构造方法(参数列表);
例如：
e1=Employee();
e2=Employee("小明",29,3000);
2.3 声明并创建对象
对象的声明和创建可以一步完成，声明并创建对象的语法结构如下：
类名 对象名 =new 构造方法名(参数列表);
Employee e1=new Employee();
Employee e2=new Employee("张三",29,3000);
分析：
第一行是调用无参的构造方法，第二个是调用有参的构造方法。
对象创建之后，就可以访问对象的属性和方法，格式为：
对象名.属性名;
对象名.方法(实参);
例如：
public class EmployeeTest {//定义EmployeeTest类
public static void main(String[] args) {
Employee e1=new Employee();//调用构造方法，实例化对象e1
e1.name="王一";//e1对象使用name属性并赋值为“王一”
e1.salary=1600;//e1对象使用salary属性并赋值为1600
e1.raise(100);//e1对象调用raise方法，raise方法为普通方法
//调用有参的构造方法，实例化对象e2，传入实参（"张敏",29,3000）
Employee e2=new Employee("张敏",29,3000);
e2.raise(500);//e2对象调用raise方法，raise方法为普通方法
}
}
3 方法的调用
调用方法的格式为：
对象名.方法名(实参);
注：实参为真正参加于计算的数，为最后的数，而不是临时使用的数。
根据方法是否有返回值，通常有两种途径调用方法：
（1）方法的返回一个值，对方法的调用就当做处理一个值。
（2）方法返回void，对方法的调用必定是一条语句。
例如：
e1.raise(100);
e2.raise(500);
void raise(double p){//定义raise方法
salary=salary+p;
System.out.println(name + "涨工资之后的工资为：" + salary);
}
分析：
raise方法返回值类型为void，所以当一条语句来调用，raise方法的定义时带一个参数（double p），调用时也要带一个参数（100/500），调用时的参数称为实参（100/500），要求实参必须在类型、数量上与形参（double p）完全匹配。
变量的作用域，是指变量在程序中的可使用范围。
类由两部分构成，一部分是属性的定义；一部分是方法的定义（一个类中可以有多个方法）。
类的属性就是定义在类的内部、方法的外面的变量，属性的作用域是整个类。
定义在方法内的变量，称为局部变量。局部变量必须先声明后使用。形参实际上就是一个局部变量。
class Employee {//员工类
//属性声明
String name;
int age;
double salary;
void raise(double p){//定义raise方法
salary=salary+p;
System.out.println(name + "涨工资之后的工资为：" + salary);
}
}
分析：
在Employee类中的name、age和salary属性，他们的作用域都是整个类的内部，可以在raise方法中应用name、age和salary属性。而形参p的作用域只是在raise方法的内部，出了raise方法，p就不能被使用了。
如果局部变量和类中的变量同名，那么优先使用局部变量。
public class VariableScope {
int x = 0;
int y = 0;
void method1() {
int x = 1;//局部变量优先
System.out.println("局部变量 x=" + x);
System.out.println("属性 y=" + y);
}
void method2() {
System.out.println("属性 x=" + x);
System.out.println("属性 y=" + y);
}
public static void main(String[] args) {
VariableScope e = new VariableScope();
e.method1();
e.method2();
}
}
分析：
类中的变量下x，y，在method1中有与类中的变量同名x，则优先使用局部变量x，即x=1输出。
输出结果为：
如果此时还需要使用属性的值怎么办呢？
使用this关键字。
this的用途，一，引用属性；二，引用构造方法。
有时为了能够在方法中引用隐藏的属性，就可以使用this区分，由this引用就是属性。
引用属性
class Person {
private String name;
private int age;
public Person(String name, int age) {
// 局部变量name,age把Person类的属性屏蔽
this.name = name;
this.age = age;
}
}
引用构造方法
注意事项:
1.this() 不能使用在普通方法中 只能写在构造方法中
2.必须是构造方法中的第一条语句
public class Platypus {
String name;
Platypus(String name){//有参构造方法
this.name=name;
}
Platypus(){//无参构造方法
this("Dear John");
}
public static void main(String[] args) {
Platypus p1=new Platypus();//实例化p1对象
Platypus p2=new Platypus("amy");//实例化p2对象
System.out.println(p1.name);//p1对象调无参构造方法
System.out.print(p2.name);//p2对象调用有参的构造方法
}
}
运行结果：
分析：
第一个构造方法，给类的成员name赋值；第二个构造方法，调用第一个构造方法，给成员变量name一个初始值“Dear John”。
作用：让一个类的所有实例来共享一个变量的值。
共享的方法就是使用static修饰。用static修饰的属性，称为静态属性或类属性（而不是类的属性）。
static可以修饰的元素包括：属性、方法和代码块。
static只能修饰类成员，不能修饰局部变量。
静态变量定义格式为：
static 数据类型 变量名;
class Chinse{
static String country;//country为静态变量
}
类常量的定义格式为：
final static 数据类型 变量名=值;
class Chinse{
static int age=10;//age为静态类常量
}
静态变量有两种方式可以对其进行访问：
（1）直接访问：类名.属性。
（2）实例化后访问：对象名.属性。
一个方法有static修饰，这个方法就是静态方法或类方法（而不是类的方法），类方法定义格式为：
[修饰符] static 返回值类型 方法名(参数列表){
//方法体
}
例如：
static void sing(){
System.out.println("北京欢迎你");
}
访问静态方法方式：
（1）直接访问：类名.方法名();
（2）实例化后访问：对象名.方法名();
使用静态方法注意：
（1）静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员；
（2）静态方法中不能使用this、super关键字；
（3）静态方法不能被非静态方法覆盖，static不能修饰构造方法。
static还能修饰静态代码块。
当类被载入时，静态代码块被执行，且只被执行一次，静态代码块经常用来进行类属性的初始化。
例如：
static {
System.out.println("北京欢迎你");
}
例题：
public class StaticTest {
public static void main(String[] args) {
Employee2.setMin(600); //类名直接访问静态方法
Employee2 e1 = new Employee2("张三",29,3000);//实例化e1对象
System.out.println("e1中员工最低工资：" + e1.getMin()); //e1对象调用getMin
Employee2 e2 = new Employee2("李四",22,300);//实例化e2对象
System.out.println("e2中员工最低工资：" + e2.getMin());//e2对象调用getMin
e1.raise(500);
e2.raise(400);
}
}
class Employee2 { //定义Employee2类，有4个属性
String name;
int age;
double salary;
static double min_salary; //让实例e1、e2共享min_salary属性的值
public Employee2(String n,int a,double s){ //有参构造方法
this.name = n;
this.age = a;
this.salary = s;
}
public static double getMin(){//静态方法
return min_salary; //返回min_salary属性值
}
public static void setMin(double min){ //setMin为静态方法，min为形参
min_salary = min;
}
void raise(double p){ //定义raise方法，参数为p
if(salary < min_salary)
salary = min_salary;
else
salary = salary+p;
System.out.println(name + "涨工资之后的工资为：" + salary);
}
}
运行结果：
分析：让实例e1、e2共享min_salary属性的值
class Chinese{
String name;
static String country;
String age;
static {
System.out.println("静态代码块");
}
static void sing() {
System.out.println("北京欢迎你");
}
}
public class ChineseTest {
public static void main(String[] args) {
Chinese zhao=new Chinese();
zhao.country="china";
Chinese wang=new Chinese();
Chinese.sing();
zhao.sing();
}
}
运行结果：
分析：
定义一个Chinses类，类里面有name属性，静态country属性，age属性；还有静态代码块；此外，有静态方法sing。
主类。实例化zhao对象，zhao对象country属性赋“china”值。实例化wang对象。China类名直接访问静态方法sing。zhao对象访问静态方法sing。
小结：
1 类的定义使用class关键字，一般不使用修饰符。
2 类的属性描述一个类的特性，如人的性别等。
3 类的方法用来描述类的活动或动作，即一系列动作。
4 构造方法必须与定义它的类有完全相同的名字。构造方法在它定义类里面。一般使用public修饰符。
5 创建对象就是使用new关键字，类是抽象的，对象是具体的。对象创建之后，就可以访问对象的属性和方法。
6 调用方法的格式为：对象名.方法名(实参);
7 定义在方法内的变量，称为局部变量。局部变量必须先声明后使用。形参实际上就是一个局部变量。
8 this的用途，一，引用属性；二，引用构造方法。
9 static关键字作用：让一个类的所有实例来共享一个变量的值。
