5)面向对象

面向对象特征

封装 继承 多态

成员变量 属性 类中方法外

成员方法 行为 去掉static

类：相关属性和行为的集合

对象：一类事物的具体体现

//创建对象格式
 类名 对象名=new 类名();
 //使用
 对象名.变量名
 对象名.方法名
 car a1=new car();
 a1=null;
 //没有变量指向该对象 该对象会变成垃圾
成员变量：类中方法外          在对象内 堆 有默认初始化值         生命随对象
方法变量：方法定义或方法声明   在方法内 栈  
无初始化 必须定义赋值   生命随着方法


引用数据类型变量 数组 类 接口 枚举

匿名对象 new Car.run(); 只适合一次调用 创建多次就生成多个对象
new  Car.color="red";
new Car.num=8;
运行是null和0
匿名对象可以调用属性 会变成垃圾 无意义
需要赋值不能用

匿名对象可以作为参数传递

method（new car()）;
//new car()产生一个地址

封装：隐藏对象属性和实现细节 对外提供公共方式
好处：隐藏细节 提高复用性 提高安全性
原则：不需要对外提供内容隐藏起来隐藏属性 公共对外公共方法访问

private 可以修饰成员变量成员方法
在类里面 setAge() getAge() 改变     


this关键字 代表当前对象引用 用来区分成员变量局部变量   

package haha;

import java.util.Date;
import java.util.GregorianCalendar;

public class EmployeeTest {

	public static void main(String[] args) {
		Employee[] staff=new Employee[3];
		staff[0]=new Employee("Carl Cracker", 75000, 1987,12,15);
		staff[1]=new Employee("Harry Hacker", 50000, 1989,10,1);
		staff[2]=new Employee("Tony Tester", 40000, 1990,3,15);
		
		for (Employee e : staff) {
			e.raiseSalary(5);
		}
		for (Employee e : staff) {
			System.out.println("name="+e.getName()+",salary="+e.getSalary()+",hireday="+e.getHireDay());
			
		}
			
		
	}

}
class Employee
{
	private String name;
	private double salary;
	private Date  hireDay;
	
	public Employee() {
	}

	public Employee(String name, double salary, int year,int month,int day) {
		this.name = name;
		this.salary = salary;
		GregorianCalendar calendar=new GregorianCalendar(year,month-1,day);
		//0代表一月
		hireDay=calendar.getTime();
	}

	public String getName() {
		return name;
	}

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

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Date getHireDay() {
		return (Date) hireDay.clone();
	//如果返回引用型数据类型 用clone 不然破坏封装
	}

	public void setHireDay(Date hireDay) {
		this.hireDay = hireDay;
	}
	public void raiseSalary(double byPercent)
	{
		double raise=salary*byPercent/100;
		salary+=raise;
	}
}
//final 构建(new)对象是初始化的域
//static  静态域属于类 即使没有一个对象也存在
//静态常量public static final
//静态方法是不能向对象实施操作的方法 如Math.pow(x,2);
//使用时 不需要math对象 没有隐氏参数
//静态方法不能访问实例域 只能访问静态域
//使用：不需要访问对状态 只需要显式参数或者方法只访问静态域 非静态方法也可以访问静态域

package haha;

public class StaticTest {
     public static void main(String[] args) {
		Employee1[] staff=new Employee1[3];
		staff[0]=new Employee1("Tom",40000);
		staff[1]=new Employee1("Dick",60000);
		staff[2]=new Employee1("Harry",65000);
		for (Employee1 e : staff) {
			e.setId();
			System.out.println("name="+e.getName()+",id="+e.getId()+",salary="+e.getSalary());			
		}
		int n=Employee1.getNextId();//静态方法直接类名调用
		System.out.println("Next availble id="+n);
	}
}
class Employee1
{
	private static int nextId=1;
	
	private String name;
	private double salary;
	private int  id;
	public Employee1() {}
	public Employee1(String name, double salary) {
		this.name = name;
		this.salary = salary;
		id=0;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public int getId() {
		return id;
	}
	public void setId() {
		id=nextId;
		nextId++;
	}
	public static int getNextId() {
		return nextId;
	}
	
	
	
}

package haha;

public class ParamTest {
	public static void main(String[] args) {
		//测试一 方法不能修改数字参数
		System.out.println("Testing TripleValue");
		double percent=10;
		System.out.println("Before:percent="+percent);
		tripleValue(percent);
		System.out.println("After:percent="+percent);
		
		
		//测试二 方法能改变对象参数状态
		System.out.println("\nTesting tripleSalary:");
		Employee3 harry=new Employee3("Harry", 50000);
		System.out.println("Before:salary="+harry.getSalary());
		tripleSalary(harry);
		System.out.println("After:salary="+harry.getSalary());
		
		//测试三 方法不能分配新对象参数
		System.out.println("\nTesting swap:");
		Employee3 a=new Employee3("Alice", 70000);
		Employee3 b=new Employee3("Bob", 60000);
		System.out.println("Before:a="+a.getName());
		System.out.println("Before:b="+b.getName());
		swap(a,b);
		System.out.println("After:a="+a.getName());
		System.out.println("After:b="+b.getName());
	
}
	public static void tripleValue(double x)
	{
		x=3*x;
		System.out.println("End of method:x="+x);
		
	}
	
	public static void tripleSalary(Employee3 x)
	{
		x.raiseSalary(200);
		System.out.println("End of method:salary="+x.getSalary());
	}
	public static void swap(Employee3 x,Employee3 y)
	{
		Employee3 temp=x;
		x=y;
		y=temp;
		System.out.println("End of method:x="+x.getName());
		System.out.println("End of method:y="+y.getName());
	}
}


class Employee3
{
	private String name;
	private double salary;
	public Employee3(String name, double salary) {
		this.name = name;
		this.salary = salary;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public void raiseSalary(double byPercent)
	{
		double raise=salary*byPercent/100;
		salary+=raise;
	}
	
}
/*Testing TripleValue
Before:percent=10.0
End of method:x=30.0
After:percent=10.0

Testing tripleSalary:
Before:salary=50000.0
End of method:salary=150000.0
After:salary=150000.0

Testing swap:
Before:a=Alice
Before:b=Bob
End of method:x=Bob
End of method:y=Alice
After:a=Alice
After:b=Bob
*/

构造器

package haha;

import java.util.Random;

public class Constructor {

	public static void main(String[] args) {
	
                Employee4[] staff=new Employee4[3];
                
                staff[0]=new Employee4("harry",40000);
                staff[1]=new Employee4(60000);
                staff[2]=new Employee4();
                
                for (Employee4 e : staff) {
					System.out.println("name="+e.getName()+",id="+e.getId()+",salary="+e.getSalary());
				}
	}

}
class Employee4
{
	private static int nextId;
	private int id;
	private String name="";
	private double salary;
	//静态初始化块
	static 
	{
		Random generator=new Random();
		//set nextId between 0 and 9999
		nextId=generator.nextInt(10000);		
	}
	
	//对象初始化块
	{
		id=nextId;
		nextId++;
	}
	//三个重载构造器
	public Employee4(String name,double salary)
	{
		this.name=name;
		this.salary=salary;
	}
	public Employee4(double salary)
	{
		//calls 第一个构造方法
		this("Employee4#"+nextId,salary);
		//this调用同一个类另一个构造器 
	}
	public Employee4()
	{
		
	}
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public double getSalary() {
		return salary;
	}
	 
}
//name=harry,id=1220,salary=40000.0
//name=Employee4#1221,id=1221,salary=60000.0
//name=,id=1222,salary=0.0