java—类和对象

类是封装对象的属性和行为的载体，类中对象的行为是以方法的形式进行定义的，对象的属性是以成员变量的形式定义的。

面向对象的特点：
（1）封装性
封装是面向对象的核心，将对象的属性和行为封装起来，其载体就是类，类通常对用户隐藏其实现细节，这就是封装的思想。
（2）继承性
类与类之间的关系被称为关联，继承是关联的一种。继承性主要利用特定对象之间的共有属性，继承关系可以使用树形关系来表示，一个类既可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法。
（3）多态性
将父类对象应用于子类的特征就是多态。多态的实现并不依赖类，而是依赖于抽象类（通常是父类）和接口。

package hello;

class Person {
	int age;// 类中定义的变量称为成员变量

	void speak() {
		// 如果在speak（）成员方法内部定义的变量被称作局部变量
		System.out.println("我今年" + age + "岁！");
	}
}

public class Main {
	public static void main(String[] args) {
		// 创建对象 类名 对象名称=new 类名（）；
		Person p1 = new Person();
		Person p2 = new Person();
		// 为对象的age属性赋值。 访问对象成员：对象引用.对象成员
		p1.age = 18;
		// 调用对象的方法
		p1.speak();
		p2.speak();
	}
}

/*输出结果
 * 我今年18岁！
 * 我今年0岁！
 */

1.成员方法

权限修饰符  返回值  方法名（参数类型  参数名）

{

       //方法体

       return  返回值；

}

2.权限修饰符  （public、protected、默认、private）

—— 用于控制被修饰变量、方法、类的可见范围. 

存在继承关系时，父类不可以是 private，因为子类无法继承 ；顶层类可以处于公开或默认级别，顶层类不能被 protected 和 private 修饰.；局部变量不能被访问控制修饰符修饰 . 

在不同包下面能够访问的权限修饰符只有： pulbic 与protected，但是 protected 必须要有继承的关系才能够访问。

3.构造方法

构造方法是一个与类同名的方法，对象的创建就是通过构造方法来完成的，每当类实例化一个对象时，类都会自动地调用构造方法。

为了方便实例化对象，构造方法通常会使用public来修饰

①　方法名与类名相同
②　在方法名的前面没有返回值类型的声明
③　在方法中不能使用return语句返回一个值

如果类中没有明确的构造方法，编译器会自动创建一个不带参数的默认构造方法。

—构造方法的重载

Person类中定义了两个构造方法，它们构成重载。在创建p1对象和p2对象时，根据传入参数的不同，分别调用不同的构造方法。

package hello;
class Person {
	String name;
	int age;

	// 定义两个参数的构造方法
	public Person(String con_name, int con_age) {
		name = con_name;
		age = con_age;
	}

	// 定义一个参数的构造方法
	public Person(String con_name) {
		name = con_name;
	}

	public void speak() {
		System.out.println("我叫:" + name + "，我今年 " + age + "岁！");
	}
}

public class Main{
	public static void main(String[] args) {   
		// 分别创建两个对象p1和p2
		Person p1 = new Person("小华");
		Person p2 = new Person("小明", 18);
		p1.speak();
		p2.speak();
	}
}

/*
输出结果：
我叫:小华，我今年 0岁！
我叫:小明，我今年 18岁！
*/

4.this关键字

在使用变量表示年龄时，构造方法中使用的是con_age，成员变量使用的是age，这样程序的可读性很差。这时需要将一个类中表示年龄的变量进行统一的命名，例如都命名为age，但这样又会导致成员变量和局部变量的名称冲突，在方法中将无法访问成员变量age，java则提供了一个关键字this。

 

1）明确的访问一个类的成员变量，解决与局部变量名称冲突问题。

class Person {
	int age;

	public Person(int age) {
		this.age = age;
	}

	public int getAge() {
		return this.age;
	}
}

2）通过this关键字调用成员方法。

class Person {
	public void openMouth() {
		// .....
	}

	public void speak() {
		this.openMouth();// this关键字可以省略不写。
	}
}

3） 构造方法是在实例化对象时被java虚拟机自动调用的，在程序中不能调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this([参数请，参数2...])”的形式来调用其他的构造方法。

class Person {
	public Person() {
		System.out.println("无参的构造方法被调用了...");
	}

	public Person(String name) {
		this();
		System.out.println("有参的构造方法被调用了...");
	}
}

public class Main {
	public static void main(String[] args) {
		/* 在实例化对象时，调用了有参的构造方法，在该方法中通过this()调用了无参的构造方法因此运行结果中显示两个构造方法都被调用了。 */
		Person p = new Person("itcast");
	}
}

在使用this调用类的构造方法时，应注意以下几点：

①　只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。

②　在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次！

③　不能在一个类的两个构造方法中使用this互相调用。

5.static关键字

在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据，只有通过new关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据，有时，我们希望某些特定的数据在内存中只有一份，而且能够被一个类的所有实例对象所共享，例如某个学校的所有学生共享同一个学校的名称。通常我们将这个常量设为静态的。

被声明为static的变量、常量和方法被称为静态成员。

语法：   类名 .静态成员     不建议使用对象.静态成员，因为这样不容易区分静态成员和非静态成员。

（1）静态变量

package hello;

class Student {
	// 在Student类中定义一个静态变量，被所有实例对象所共享
	static String schoolName;
}

public class Main {
	public static void main(String[] args) {
		// 创建学生对象
		Student stu1 = new Student();
		Student stu2 = new Student();
		// 为静态变量赋值
		Student.schoolName = "zufe";
		System.out.println("我的学校是" + stu1.schoolName);
		System.out.println("我的学校是" + stu2.schoolName);
	}
}
/*输出结果
我的学校是zufe
我的学校是zufe
*/

注意：java中规定不能将方法体内的局部变量声明为static的；

（2）静态方法

有时我们希望在不创建对象的情况下就可以调用某个方法，就是说方法不必和对象绑在一起，那么只要在类中定义的方法前加上static关键字即可。

package hello;
class Person {
	// 定义静态方法
	public static void sayHello() {
		System.out.println("hello");
	}
}

public class Main {
	public static void main(String[] args) {
		Person.sayHello();
	}
}
/*输出结果：
hello
*/

（3）静态代码类

在java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次，在程序中，通常会使用静态代码块来对类的成员变量进行初始化。

package hello;

class Person {
	static String country;
	// 下面是一个静态代码块
	static {
		country = "china";
		System.out.println("Person类中的静态代码执行了");
	}
}

class Main {
	// 静态代码块
	static {
		System.out.println("测试类的静态代码块执行了");
	}

	public static void main(String[] args) {
		// 下面的代码创建了两个Person对象
		Person p1 = new Person();
		Person p2 = new Person();
	}
}

6.类的主方法

主方法是类的入口点，java编译器通过主方法来执行程序。

public static void main(String[] args)

{

     //方法体

}

主方法的特点：

1）主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须也是静态的。

2）主方法没有返回值。

3）主方法的形参为数组，其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length获取参数的个数。

编写一个类，定义一个修饰权限为private的成员变量，并定义两个成员方法，一个为此成员赋值，另一个获取此成员变量的值，保证其他类继承该类时能获取该类的成员变量的值。

package hello;

public class UseCase1 {
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

package hello;

public class UseCase2 extends UseCase1{

	
	public static void main(String[] args) {
		UseCase1 u=new UseCase1();
		u.setName("123");
		System.out.println(u.getName());
	}

}

输出结果：123

7.对象

对象是由类抽象出来的，对象可以认为是在一类事物抽象中出某一个特例。

1）对象的创建

在java语言中使用new操作符调用构造方法创建对象。

Test  test = new Test ("a") ;  （a为构造方法的参数） test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，可以在构造方法中初始化成员变量，当创建对象时，自动调用构造方法，也就是说，java语言中初始化和创建是被捆绑在一起的。

2）访问对象的属性和行为 

对象.类成员

package hello;
public class TransferProperty {
	int i = 47; // 定义成员变量

	public void call() { // 定义成员方法
		System.out.println("调用call()方法");
		for (i = 0; i < 3; i++) {
			System.out.print(i + " ");
			if (i == 2) {
				System.out.println("\n");
			}
		}
	}

	public TransferProperty() { // 定义构造方法
	}

	public static void main(String[] args) {
		TransferProperty t1 = new TransferProperty(); // 创建一个对象
		TransferProperty t2 = new TransferProperty(); // 创建另一个对象
		t2.i = 60; // 将类成员变量赋值为60
		// 使用第一个对象调用类成员变量
		System.out.println("第一个实例对象调用变量i的结果：" + t1.i++);
		t1.call(); // 使用第一个对象调用类成员方法
		// 使用第二个对象调用类成员变量
		System.out.println("第二个实例对象调用变量i的结果：" + t2.i);
		t2.call(); // 使用第二个对象调用类成员方法
	}
}

/*输出结果
  第一个实例对象调用变量i的结果：47
调用call()方法
0 1 2 

第二个实例对象调用变量i的结果：60
调用call()方法
0 1 2 

*/

如果希望成员变量不被其中任何一个对象改变，可以使用static关键字

public class AccessProperty {
	static int i = 47; // 定义静态成员变量

	public void call() { // 定义成员方法
		System.out.println("调用call()方法");
		for (i = 0; i < 3; i++) {
			System.out.print(i + " ");
			if (i == 2) {
				System.out.println("\n");
			}
		}
	}

	public AccessProperty() { // 定义构造方法
	}

	public static void main(String[] args) { // 定义主方法
		AccessProperty t1 = new AccessProperty(); // 创建一个对象
		AccessProperty t2 = new AccessProperty(); // 创建另一个对象
		t2.i = 60; // 将类成员变量赋值为60
		// 使用第一个对象调用类成员变量
		System.out.println("第一个实例对象调用变量i的结果：" + t1.i++);
		t1.call(); // 使用第一个对象调用类成员方法
		// 使用第二个对象调用类成员变量
		System.out.println("第二个实例对象调用变量i的结果：" + t2.i);
		t2.call(); // 使用第二个对象调用类成员方法
	}
}
/*输出结果
第一个实例对象调用变量i的结果：60
调用call()方法
0 1 2 

第二个实例对象调用变量i的结果：3
调用call()方法
0 1 2 

*/

由于使用t2.i=60语句改变了静态成员变量的值，使用对象t1调用成员变量的值也是60，这正是i值被定义为静态成员变量的效果，因为在内存中两个对象同时指向同一块内存区域，t1.i++语句执行完毕后，i值变为3，当再次调用call（）方法时又被重新赋值为0，故循环打印操作。

3）对象的比较

两种对象比较的方式: "=="运算符和equals()方法

“==”比较的是两个对象引用的地址是否相等；equals()方法是String类中的方法，比较两个对象引用所指的内容是否相等。

package hello;

public class Main {
	public static void main(String[] args) {
		String c1 = new String("abc"); // 创建两个String型对象引用
		String c2 = new String("abc");
		String c3 = c1; // 将c1对象引用赋予c3
		// 使用“==”运算符比较c2与c3
		System.out.println("c2==c3的运算结果为：" + (c2 == c3));
		// 使用equals()方法比较c2与c3
		System.out.println("c2.equals(c3)的运算结果为：" + (c2.equals(c3)));
	}
}
/*输出结果
c2==c3的运算结果为：false
c2.equals(c3)的运算结果为：true
*/

8.对象的销毁  垃圾回收

java拥有一套完整的垃圾回收机制， 将被视作垃圾：对象引用超过其作用范围：将对象赋值为null。但是垃圾回收器只能回收那些由new操作符创建的对象。除了等待java虚拟机进行自动垃圾回收，也可以通过调用System.gc()方法来通知java虚拟机在后台立即进行垃圾回收。程序结束后，垃圾回收的操作也将终止。
 当一个对象在内存中被释放时，她的finalize()方法会被自动调用，因此可以在类中通过定义finalize（）方法来观察对象何时被释放。这个方法是Object类的方法，被声明为protected。

class Person{
	//下面定义的finalize方法会在垃圾回收之前被调用，必须要用public 和void。
	public void finalize(){
		System.out.println("对象将被作为垃圾回收...");
	}
}
public class helloworld{
	public static void main(String []args){
		//下面创建了两个Person对象
		Person p1=new Person();
		Person p2=new Person();
		//下面将变量置为null，让对象成为垃圾
		p1=null;
		p2=null;
		//调用方法进行垃圾回收
		System.gc();
		for(int i=0;i<100000;i++)
		{
			//为了延长程序运行的时间
		}
	}
}
/*输出：
对象将被作为垃圾回收...
对象将被作为垃圾回收...
*/

eg.编写一个矩形类，将长与宽作为矩形类的属性，在构造方法中将长宽初始化，定义一个成员方法求此矩形的面积

package hello;

public class UseCase3 {
	private float height;
	private float width;
	public UseCase3(float height,float width){  //构造方法
		this.height=height;
		this.width=width;
	}
	public float square(){   //成员方法
		return height*width;
	}
	public static void main(String args[]){
		UseCase3 u=new UseCase3(3.5f,4.5f);
		System.out.println(u.square());
	}
}
/*输出结果
 * 15.75
 */