Java学习（四）：面向对象

一、面向对象的三大特征

1、封装

• 对外部不可见

2、继承

• 拓展类的功能

3、多态

• 方法的重载
• 对象的多态

二、类的定义

类定义完成之后，需要创建并实例化对象才能使用。

示例：

三、声明并实例化对象

1、声明并实例化单个对象：

对象保存在栈内存之中，属性保存在堆内存之中，方法则是保存在全局代码区，此代码区是所有对象共享的。

Person per = new Person();

• 声明对象： Person per ,是在栈内存中声明的，和数组名称一样，必须要有其堆内存的引用才可以使用
• 实例化对象： new Person()，是在堆内存中开辟空间，并赋默认值。

或者这样声明并实例化对象：

Person per = null；
per = new Person()；

示例：

class Person{
	String name;
	int age;
	public void tell(){
		System.out.println("姓名："+ name + "，年龄：" + age);
	}
};

public class demo {
	public static void main(String args[]) {
		Person per = new Person();//声明并实例化对象per
		per.name = "庞先生";//给per对象赋值
		per.age = 22;
		per.tell();
	}
}

如果只声明了对象，而没有实例化，即对象没有其堆内存的空间指向（指针），会报错：

Exception in thread “main” java.lang.NullPointerException
at demo.main(demo.java:13)
出现了一个空指向异常

2、声明并实例化多个对象：

public class demo {
	public static void main(String args[]) {
		Person per1 = new Person();//声明并实例化对象
		Person per2 = new Person();//声明并实例化对象
		per1.name = "庞先生";
		per2.name = "黄先生";
		per1.age = 22;
		per2.age = 21;
		per1.tell();//调用per1对象的tell方法
		per2.tell();//调用per2对象的tell方法
	}
}

对象的引用传递：

3、栈与堆内存的关系

情况一：对象的引用传递

public class demo {
	public static void main(String args[]) {
		Person per1 = new Person();//声明并实例化对象
		Person per2 = per1;//引用per1的对象，把per1的堆内存空间使用权给per2
		per1.name = "庞先生";//初始化per1对象的属性
		per1.age = 22;
		per1.tell();
		per2.name = "黄先生";//利用per2对象修改per1的属性
		per2.age = 21;
		per1.tell();//还是调用per1对象方法，看per1的属性是否被per2改动
	}
}

per1和per2对象都指向同一个堆内存空间，并不会为per2多分配一个内存空间。

情况二：重新指向另一对象

public class demo {
	public static void main(String args[]) {
		Person per1 = new Person();//声明并实例化对象
		Person per2 = new Person();
		per1.name = "庞先生";//初始化per1对象的属性
		per1.age = 22;
		per2.name = "黄先生";
		per2.age = 21;
		per1.tell();
		per2.tell();
		
		per2 = per1;//改变per2对象的堆内存空间指向，指向per1的空间。
		System.out.println("修改后：");
		per1.tell();//调用per2对象方法，看per2的属性是否和per1一样
		per2.tell();
				
	}
}

四、Java的封装

封装就是保护内容保护某些方法或属性不被暴露在外面。
使用private 类声明私有方法或私有属性

封装类的属性

class Person{
	private String name;
	private int age;
	public void tell(){
		System.out.println("姓名："+ name + "，年龄：" + age);
	}
};

访问封装内容

被封装属性如果需要被访问，可以自定义set…方法和get…方法，并且为set、get方法设置参数过滤

class Person{
	private String name;
	private int age;
	public void tell(){
		System.out.println("姓名："+ name + "，年龄：" + age);
	}
	//设置名字方法
	public void setName(String str) {
		if (str.length()<10) {
			name = str;
		}else {
			System.out.println("名字过长");
		}
	}
	//取得名字方法
	public String getName() {
		return name;
	}
	//设置年龄方法
	public void setAge(int n) {
		if (n>0&&n<100) {
			age = n ;
			
		}else {
			System.out.println("年龄不符合要求");
		}
	}
	//取得年龄方法
	public int getAge() {
		return age;
	}
};
public class demo {
	public static void main(String args[]) {
		Person per1 = new Person();//声明并实例化对象
		per1.setName("庞先生");
		per1.setAge(22);
		int age = per1.getAge();
		String name = per1.getName();
		System.out.println("姓名："+name+"，年龄："+age);			
	}
}

五、构造方法

对象实例化→调用构造方法
构造方法的目的是为类中的属性初始化。
当类中没有自定义的构造方法时，将会自动创建一个默认的无参的构造方法。

1、定义构造方法

• 构造方法的名称必须与类名称一直
• 构造方法的声明不能有任何返回值的定义（包括void都不行，直接就public 类名称() ）
• 不能在构造方法中使用return返回一个值

class Person{
	private String name;
	private int age;
	
	public Person(String str, int a) {			//声明构造方法，传递参数为类的属性初始化
		this.setName(str);
		this.setAge(a);
		
	}
		
	public void setName(String str) {
		if (str.length()<10) {
			name = str;
		}else {
			System.out.println("名字过长");
		}
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int n) {
		if (n>0&&n<100) {
			age = n ;
			
		}else {
			System.out.println("年龄不符合要求");
		}
	}
	
	public int getAge() {
		return age;
	}
};

public class demo {
	public static void main(String args[]) {
		Person per1 = new Person("庞先生",22);		//实例化对象并且赋初始值
		//per1.setName("庞先生");				//原来的使用封装方法赋值
		//per1.setAge(22);
		String name = per1.getName();
		int age = per1.getAge();
		System.out.println("姓名："+name+"，年龄："+age);			
	}
}

2、构造方法的重载：

public Person() {}; 		//声明一个无参的构造方法
public Person(String str) {		//声明一个只有一个参数的构造方法
	this.setName(str);
};
public Person(String str, int a) {			//声明构造方法，传递参数为类的属性初始化
	this.setName(str);
	this.setAge(a);
}

3、匿名对象：

如果一个对象只使用一次，则可以使用匿名对象。
也就是说可以声明一个没有名字的对象指向堆内存，即不开辟栈内存空间存放对象名，仅开辟一个堆内存空间存放对象的属性。

public static void main(String args[]) {
		new Person("庞先生",22).tell();
		//Person per1 = new Person("庞先生",22);		//实例化对象并且赋初始值
		//per1.setName("庞先生");				//原来的使用封装方法赋值
		//per1.setAge(22);
		//String name = per1.getName();
		//int age = per1.getAge();
		//System.out.println("姓名："+name+"，年龄："+age);	
		
	}

六、类分析设计

对于任何一个程序，对类分析思路的步骤：

1. 根据要求写出类所包含的属性
2. 所有的属性都必须进行封装（private）
3. 封装之后的属性通过setter和getter设置和取得
4. 如果需要可以加入不同参数的构造方法进行重载
5. 添加所需的自定义方法
6. 类中的方法不能直接输出，而是要交给被调用处输出

设计出类图：

按照类图构造代码