java5.txt

达内IT培训Core Java全部笔记 是学习Java编程的好东西

sd 0804 Javaday5   2008年6月17日
日期作业：
package com.tarena.day05;

public class MyDate {
		private int year;
		private int month;
		private int day;
		public MyDate(){
//			year = 2008;
//			month = 1;
//			day = 1;
		}
		public MyDate(int year, int month, int day){
				this.setYear(year);
				this.setMonth(month);
				this.setDay(day);
		}
		
	public int getDay() {
			return day;
		}
		public void setDay(int day){
			if(year == 0 || month == 0){
				System.out.println("err");
				return;			//return可以让一个返回void的方法终止
			}
			int maxDay = 31;
			if(month==4 ||month==6 ||month==9 ||month==11){
				maxDay = 30;
			}else if(month==2){
				if(year%4==0 && year%100!=0 || year%400==0){
					maxDay = 29;
				}else{
					maxDay = 28;
				}
			}
			if(day<1 || day>maxDay){
				System.out.println("Day error!");
			}else{
				this.day = day;
			}
		}
		public int getMonth(){
			return month;
		}
		public void setMonth(int month){
			if(month<1 || month>12){
				System.out.println("month error!");
			}else{
				this.month = month;
			}
		}
		public int getYear(){
			return year;
		}
		public void setYear(int year) {
			if(year<0){
				System.out.println("year error!");
			}else{
				this.year = year;
			}
		}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
-----------------------------------------------------------------------------------------------------------






访问权限：
一个类/方法/属性/构造的可访问范围
-----------------------------------------------------------------------------------------------------------
package com.tarena.day05;

public class TestAccess {
	private String name1;
	String name2;
	protected String name3;
	public String name4;
	

}
-----------------------------------------------------------------------------------------------------------
package com.tarena.day05;

public class Test1 {

	public static void main(String[] args) {
				TestAccess ta = new TestAccess();
				//ta.name1 = "";	 //在类外，私有不可访问
				ta.name2 = "";
				ta.name3 = "";
				ta.name4 = "";
	}

}
-----------------------------------------------------------------------------------------------------------
package com.tarena.day05.test;

import com.tarena.day05.TestAccess;

public class Test2 extends TestAccess{
		public void test(){
			name3 = "";		//可继承
		}
	public static void main(String[] args) {
		TestAccess ta = new TestAccess();
		ta.name3 = "";		//portected 在子类中可以继承过来，支持 子类.  使用，但是不支持 父类.  使用
		ta.name4 = "";
		Test2 t = new Test2();
		t.name3 = "";

	}

}
-----------------------------------------------------------------------------------------------------------

abstract 抽象 关键字：
用来修饰类/方法

abstract class  抽象类

abstract 返回   方法名（）：	//最后没有大括号，而是用 ; 

抽象类：
1.抽象类不能 new + 构造（）
2.变量可以声明为抽象类
3.可以用一个非抽象的子类去替代赋值
4.所有抽象类的对象一定是非抽象子类的
5.抽象类有构造，子类还是会调用构造的

抽象方法：（未实现）需要调用，但是无法调用
1.无方法体
2.有方法名，有参数列表，有返回类型
3.可以定义一个方法的框架和规范

有 抽象方法不一定有抽象类，有抽象类一定有抽象方法
抽象方法具有强制性，规范性

1.帐户类（银行）
帐号
余额 ----利息（定期，活期）利率不一样.
总额 

模版：
--------------------------------------------------------------------------------------------
package com.tarena.day05.temple;

public abstract class Account {
	private double count;//余额
	private String number;//卡号，手机号多用String
	public abstract double getAll();//抽象方法，计算总额（连利息，带本金）
	public double getCount() {
		return count;
	}
	public void setCount(double count) {
		this.count = count;
	}
	public String getNumber() {
		return number;
	}
	public void setNumber(String number) {
		this.number = number;
	}
	
}

--------------------------------------------------------------------------------------------
package com.tarena.day05.temple;

public class DAccount extends Account {
	public double getAll(){//重写
		return this.getCount()*(1+0.04);
	}
}
--------------------------------------------------------------------------------------------

package com.tarena.day05.temple;

public class HAccount extends Account {
	public double getAll(){//强制+规范
		return this.getCount()*(1+0.03);
	}
	public static void main(String[] args){
		Account a = new HAccount();
		a.setCount(1000);
		System.out.println(a.getAll());
	}
}

输出结果：1030.0   //double型


说明：
1.Account现实当中无法实现
2.getAll()实现在定，活中不一样，在Account中无法实现，因此要定义为抽象
3.  保证代码的规范性，强制性（在子类中重写，强制规范了子类的方法名，参数列表，返回值）
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

接口(interface)：接口可以看作成一种抽象类（它不是类，接口支持多继承，类是单继承的）
编译后的文件也是.class 他和类编译后的.class 文件不一样，接口不是类

 		
特殊：   1.接口无构造
		2.接口里所有的属性都是：public static final(常量--所有字母大写，下划线分隔)
		3.接口所有方法都是public abstract


接口和类的区别： 不是类，可以实现多继承，无构造，方法都是抽象的，属性是static final

关键字： public interface 接口名


eg:

package com.tarena.day05.in;

public interface In1 {
	//public In1(){}
	String NAME = "zhang";//前面自动public static final --常量
	void test();//前面自动public abstract 抽象方法
		
}
--------------------------------------------------------------------------------------------
package com.tarena.day05.in;

public class Test implements In1 { //类和接口的继承（实现）

	public void test(){} // 
	public static void main(String[] args) {
		System.out.println(In1.NAME);//接口，说明NAME是static的

	}

}
--------------------------------------------------------------------------------------------
package com.tarena.day05.in;

public interface In2 extends In3, In4{
	public void test3();//接口的子类一定要重写接口中所有的方法，否则就必须声明为抽象类

}
--------------------------------------------------------------------------------------------
package com.tarena.day05.in;

public interface In3 {
	public void test1();
}
--------------------------------------------------------------------------------------------
package com.tarena.day05.in;

public interface In4{
	public void test2();
}

--------------------------------------------------------------------------------------------

类 implements 接口
	多继承，中间用，分割

接口extends 接口
	多继承，中间用，分割

接口的子类一定要重写接口中所有的方法，否则就必须声明为抽象类

abstract 不能和 static final private 一起修饰方法
private 的方法无法继承
final 的方法无法重写，而abstract 是需要重写的
static 可以用  类名.  来调用方法，而abstract 抽象方法是调用子类的方法，是  子类对象.  去调用


＊＊＊＊Object 是所有类的父类＊＊＊＊
clone() 对象复制，返回对象副本
equals(Object obj) 完成对象的比较，其他对象是否与此对象“相等”
hashCode()  返回该对象的哈希码值
toString() 用一个String来描述对象，并返回。（像对象的名片）
finalize() 为垃圾回收服务
	JVM负责运行内存垃圾回收从栈或池中无引用或无对象的就是内存垃圾
	在回收前会自动调用finalize()方法的，但finalize()不会影响垃圾回收的


以able结尾的接口代表一种规范性，clone也是一种规范
--------------------------------------------------------------------------------------------
package com.tarena.day05.object;

public class TestClone implements Cloneable{		//接口规范，代表可以克隆
	private int temp = 1;
	public static void main(String[] args) throws Exception {
			TestClone tc = new TestClone();
			Object obj = tc.clone();	//多态
			TestClone clone = (TestClone)obj;
			System.out.println(clone.temp);

	}

}
--------------------------------------------------------------------------------------------

clone()
		深克隆（递归克隆）：所有属性/属性的属性，在内存中都要重新申请空间，重新克隆
（默认）浅克隆（当前层的克隆）：只申请当前对象(包括属性)的空间
--------------------------------------------------------------------------------------------
package com.tarena.day05.object;

import com.tarena.day05.temple.DAccount;

public class TestClone implements Cloneable{		//接口规范，代表可以克隆
	private int temp = 1;
	private String name = "li";
	private DAccount da = new DAccount();
	@Override
	public Object clone() throws CloneNotSupportedException{		//让clone在类外能被访问
			return super.clone();
	}
	public static void main(String[] args) throws Exception {
			TestClone tc = new TestClone();
			Object obj = tc.clone();	//多态,name 和 da只是复制相同的指针过来
			TestClone clone = (TestClone)obj;//强制类型转换
			System.out.println(clone.temp);	//打印克隆副本中的temp
			System.out.println(tc==clone);	//检查是否是同一个对象,应为false，因为在堆中开辟了两个不同对象，所以地址不同
			clone.temp = 2;			//给clone副本中的temp赋值
			clone.name = "zhang";	//让clone新建一个指针指向String类型  "zhang",	"="基本类型改值，引用类型的改地址
			clone.da.setCount(1000);
			System.out.println(tc.temp);		//说明tc存放的内容与clone出来的地址存放的2个不同内容
			System.out.println(tc.name);		//tc中的还是"li"
			System.out.println(tc.da.getCount());
			System.out.println(clone.da.getCount());
			
	}	

}
输出结果：
1
false
1
li
1500.0
1500.0
--------------------------------------------------------------------------------------------
package com.tarena.day05.object;

public class Test {
	public static void main(String[] args) throws Exception{
			TestClone tc = new TestClone();
			Object obj = tc.clone();//父类的克隆方法不能满足子类需要,需要重写
	}
}
让clone方法在类外能被访问：
1.实现可克隆的接口
2.重写clone方法
--------------------------------------------------------------------------------------------


Object类中 equals 比较的是地址
＝＝和 equals都用于判定相等
1.基本类型用==
2.对象与空(null)的比较用==
3.对象之间的比较用equals
4.==在对象比较时，比较的是地址,equals比较的也是地址，但==不能改变，而equals可以通过方法重写而比较内容
--------------------------------------------------------------------------------------------
package com.tarena.day05.object;

public class Person{
		private int id;
		private String name;
		@Override
		public boolean equals(Object obj){		//这里写Object意味着所有类都可以传参, 参数多态
			if(obj==null){
				return false;
			}else if(obj instanceof Person){
				Person p = (Person)obj;
				return this.id == p.id;
			}
			return false;
		}
		@Override
		public int hashCode(){
			int temp = 23;		//定义一个质数代表Person类型，其他类型值会变化
			return temp+id*43;
		}
		
	public int getId() {
			return id;
		}

		public void setId(int id) {
			this.id = id;
		}

		public String getName() {
			return name;
		}

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

	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setId(1000);
		Person p2 = new Person();
		p2.setId(1000);
		System.out.println(p1.equals(p2));	//地址不同
		System.out.println(p1.hashCode());	//hashCode不是内存地址
		System.out.println(p2.hashCode());	//因为equals重写了，所以hashCode()也要重写

	}

}
输出结果：
true
43023
43023

--------------------------------------------------------------------------------------------



＊＊哈西算法＊＊
生成哈西码（整数）-> 对应内存地址

哈西码的唯一性
比较两个对象，先判断两个对象是否相等(equals），如果相等就不存，不相等的华就放入新位置
如果equals重写了，hashcode也要重写

hashcode如果重写了意味着判断对象相等的条件也应该改变