4.类，方法，对象

1.1.2. 面向对象程序设计的三大特征

1.1.2.1. 封装

面向对象编程核心思想之一就是将数据和对数据的操作封装在一起，形成一般的概念，比如类的概念。

1.1.2.2. 继承

继承体现了一种先进的编程模式。子类可以继承父类的属性和方法。

1.1.2.3. 多态

多态是面向对象编程的又一重要特征，是编写出易维护，易扩展程序的保障。

1.1.3. 类与对象的概念

1.1.3.1.类

类是一个模板或蓝图，它用来定义对象的数据域是什么以及方法是做什么的对象是类的一个实例（instance）。可以用一个类创建多个实例。创建实例的过程称为实例化（instantiation）。

对象和实例(instance)是一个概念，对象是类实例化的结果。

类和对象是抽象和具体的关系。比如汽车属于交通工具类，问界 M7 是交通工具类的一个实例。

1.1.3.2.对象

对象的两方面的特征

状态:描述对象的静态特征
行为:描述对象的动态特征

一辆汽车

状态描述：生产厂家、颜色、出厂年份、价格等
行为描述：启动、加速、转弯和停止等

一名员工:

状态描述：姓名、年龄、工资
行为描述：说话、工作、计算工资等

1.1.3.3. 消息和方法

对象和对象之间的联系是通过消息传递的，一个对象发送消息包含 3 方面的内容：接收消息的对象，接收对象采用的方法、以及方法的参数。

1.2.1. 类的定义

类（class）是一种抽象数据类型，类是构成Java程序的最基本的要素，一个Java项目应由若干类构成。

1.2.1.1. 类声明

类的定义包含两部分：类的声明和类的实现（类的主体）。主体部分包含声明数据成员和定义成员方法。具体格式如下：

[public][abstract|final]class ClassName [extends SuperClass] [implements InterfaceList]{//1.成员变量的定义//2.构造方法的定义//3.成员方法的定义...
}

说明：

类的修饰符

类的访问修饰符可以是 public 或者缺省。若类用 public 修饰，则该类称为公共类。公共类可以被任何包的类使用。如果不加 public 修饰符，类只能被同一包的其他类使用。如果类使用 abstract 修饰符，则该类为抽象类。如果类使用 final 修饰，指明该类为最终类。

extends SuperClass

如果一个类需要继承某个类使用 extends 指明该类的父类，SuperClass 为父类名，即定义了该类继承了哪个类。如果定义类的时候没有指明所继承的父类，则它自动继承自 Object 类。

implements InterfaceList

如果定义的类需要实现接口，则使用 implements InterfaceList 选项。一个类可以同时实现一个或一个以上的接口，如果实现多个接口，则接口名中间以逗号分开。

类体

类声明结束后是一对大括号{}，用大括号括起来的部分称为类体。类体中通常包括三部分内容：构造方法、成员变量、成员方法。其中构造方法用于创建类实例；成员变量定义对象状态；成员方法定义对象行为。

public class Employee {//3个成员变量的定义String name;int age;double salary;//无参数构造方法public Employee() {}//一个实例方法public void sayHello() {System.out.println("My name is " + name);}//另一个实例方法public double computeSalary(int hours, double rate) {double totalSalary = salary + hours * rate;return totalSalary;}
}

1.2.1.2. 成员变量的定义

成员变量的声明格式是：

[public|private|protected][static][final] type variableName[=value];

注意：

用 protected 修饰的变量为保护变量，可以被同一个包中的类或子类访问；

没有使用访问修饰符的变量，只能被同一个包中的类访问；

用 private 修饰的变量称为私有变量，只能被同一个类的方法访问。

实例变量和静态变量。如果变量用 static 修饰，则该变量称为静态变量，又称为类变量。没有用 static 修饰的变量称为实例变量

使用 final 修饰的变量称为最终变量，又称为常量。常量可以在声明的时候赋值，也可以在后面赋初值。一旦为其赋值，其值不能更改。

1.2.1.3. 构造方法的定义

构造方法又称为构造器（constructor），是类的一种特殊的方法。Java 中的每个类都有构造方法，它的作用是创建对象并初始化对象的状态。下面的代码定义了一个不带参数的构造方法。

public Employee();//不带参数的构造方法，方法体为空

1.2.1.4. 成员方法的定义

方法用来实现对象的动态特征，Java 的方法必须定义在类体内，不能定义在类体外。

成员方法的定义包括方法的声明和方法体的定义，一般格式如下：

[修饰符] returnType methodName([paramList]){//方法体
}

1.2.2. 创建和使用对象

一般先根据需求设计（创建）类（Employee），然后在另一个类（EmployeeDemo）中，创建该Employee 类的成员并调用Employee 类的方法。

现在创建一个Employee 类的对象，实例化，并调用该实例的变量和方法。

public class EmployeeDemo {public static void main(String[] args) {//声明并创建一个Employee对象Employee employee;employee = new Employee();//访问对象的成员（赋值）employee.name = "张三";employee.age = 28;employee.salary = 5000.00;//访问对象的成员（取值）System.out.println("姓名=" + employee.name);System.out.println("年龄=" + employee.age);System.out.println("工资=" + employee.salary);//调用对象的方法employee.sayHello();}
}
/*
姓名=张三
年龄=28
工资=5000.0
My name is 张三
*/

1.2.2.1. 用 new 创建对象

为了使用对象，一般要声明一个对象名，即声明该对象的引用(reference),然后使用 new 运算符调用类的构造方法创建对象。对象声明格式如下：

1.可以同时声明多个同类型的对象名，其中用逗号分隔

Employee emp1,emp2;

2.可以将对象的声明和创建使用一个语句完成

Employee employee;
employee=new Employee();
//(1)+(2)等价于(4)
Employee employee=new Employee();

3.若对象仅在创建处使用，也可以不声明引用名，如下面语句直接创建一个Employee对象，然后调用其sayHello()方法

new Employee().sayHello();

1.2.2.2. 对象的使用

创建一个对象引用后，可以通过点号运算符(.)来访问对象的成员变量和调用对象的成员方法。

employee.name = "张三";
employee.sayHello();

1.2.2.3. 对象引用赋值

对于对象的赋值，赋值时将该对象的引用（地址）赋值给变量

Employee employee1,employee2;
employee1 = new Employee();
employee2=employee1;	//employee1的引用赋值给employee2

public class Employee {String name;public static void main(String[] args){Employee employee1,employee2;employee1 = new Employee();employee2 = employee1;employee1.name = "张三";employee2.name = "李四";System.out.println("employee1.name=" + employee1.name);System.out.println("employee2.name=" + employee2.name);}
}
/*
employee1.name=李四
employee2.name=李四
*/

注意：employee1 和 employee2 指向同一个对象后不管后加入什么值两个对象最终都指向最后一个值 。

1.2.3. 构造方法

每个类都有构造方法（constructor），构造方法用来创建类的对象或实例。构造方法也有名称、参数和方法体。

构造方法与普通方法的区别是：

构造方法的名称必须与类名相同
构造方法不能有返回值，也不能返回void
构造方法必须在创建对象时用new运算符调用

构造方法定义的格式为:

[public|protected|private] ClassName([param list]) {// 方法体
}

注意：

public、protected和private为构造方法的访问修饰符，它用来决定哪些类可以使用该构造方法创建对象
构造方法名必须与类名相同
构造方法可以带有参数
构造方法可以不唯一

构造方法主要作用是创建对象并初始化类的成员变量。对类的成员变量，若声明时和在构造方法都没有初始化，新建对象的成员变量值都被赋予默认值。

对于不同类型的成员变量，其默认值整理如下：

整型数据的默认值是0
浮点型数据默认值是0.0
字符型数据默认值是’\u0000’
布尔型数据默认值是false
引用类型数据默认值是null

例如，假设在Employee类定义了一个构造方法Employee (String name, int age, double salary)，现在要定义一个无参数的构造方法，可以在下面的构造方法中调用该构造方法。

public Employee(){this("张三", 28, 5000);
}

Java语言规定:

1、在构造方法中调用另一个构造方法，则this语句必须是第一条语句

2、this只能用在实例方法和构造方法中，不能用在static方法中

1.3.1. 静态变量

静态变量和实例变量的区别是：

实例变量具有自己的内存区域，因此这些实例变量是不同的，通常使用实例变量名的方式来访问；

静态变量共享同一个内存区域，每个对象对静态变量的修改都会影响到其他对象，通常使用类名+静态变量名的方式访问。

public class Person {String name;int age;static String schoolName;public Person(String name,int age){this.name=name;this.age=age;}public void say(){System.out.println("我是"+this.name+",今年"+this.age+",来自"+this.schoolName);}public void setSchoolName(String schoolName){this.schoolName=schoolName;}
}

public class PersonDemo {public static void main(String[] args){Person.schoolName="A大学";Person p1=new Person("张三",18);Person p2=new Person("李四",28);p1.setSchoolName("B大学");p2.say();			//output}
}

另外，static与final一起使用来定义类常量。例如，Java类库中的Math类中就定义了两个类常量：

public static final double E = 2.718281828459045 ;              
public static final double PI = 3.141592653589793 ;

可以通过类名直接使用这些常量：

System.out.println("面积=" + Math.PI * 10 * 10);

1.3.2. 静态方法

静态方法只能访问静态变量，不允许访问实例变量，静态方法不允许使用 this、super 等关键字。通常，通过类名+静态方法名的方式来访问静态方法。

1.2.4.2. 方法重载

一个类中定义多个同名的方法，这称为方法重载（overloading）,实现方法重载，要求同名的方法。

要么参数个数不同
要么参数类型不同
仅返回值不同不能区分重载的方法

public void display (int a){System.out.println("a = "+a);	
}
public void display (double d){System.out.println("d = "+d);	
}	
public void display(){System.out.println("无参数方法");	
}	
public void display(int a,int b){System.out.println("a = "+a+",b = "+b);	
}

 public static void main(String[] args){OverloadDemo obj = new OverloadDemo();obj.display();obj.display(10);obj.display(50,60);obj.display(100.0);
}