java基础 类 3

 1.以后写代码时，只要遇到访问"对象中的成员"或"数组中的元素"，都要先进行空指针防护

 if(p!=null){
    p.aa();
 }
 

 if(p==null){
   return;
  }
 p.aa();

package cn.hncu.para2.v3;
/*
 * ※以后写代码时，只要遇到访问"对象中的成员"或"数组中的元素"，都要先进行空指针防护
 * 
 * if(p!=null){
 *   p.aa();
 * }
 * 
 * 或
 * 
 * if(p==null){
 *   return;
 * }
 * p.aa();
 * 
 */

public class Person {
	private String name;
	private int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Person() {
		this("NoName",0);
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return name + ", " + age;
	}
	
	/**
	 * 给数组的第一个元素赋整数1。
	 * @param a 传入一个非空的整数数组
	 */
	public void aa( int[] a){
		a[0]=1;
	}
	
	/*
	public boolean equals(Object obj) {
		//空指针防护
		if(obj==null){
			return false; 
		}
		
		//程序能执行到这里，obj一定不等于null
		if(obj instanceof Person){
			Person p = (Person) obj;//解决编译时多态
			if(this.name==p.name && this.age==p.age){
				return true;
			}else{
				return false;
			}
			
		}else{//obj不是Person类型，而this是
			return false;
		}
	}
	*/
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		
//		if (getClass() != obj.getClass())  //判断两者的类模板对象是否是同一个---精确匹配
//			return false;
		
		//判断obj是否是Person的一个实例----渐近匹配
		if( !(obj instanceof Person) ){
			return false;
		}
		
		Person other = (Person) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
	
	public static void main(String[] args) {
		
		Person p1 = new Person("Jack", 22);
		Person p2 = new Person("Jack", 22);
		System.out.println( p1==p2 ); //false
		
		System.out.println( p1.equals(p2) ); //true
		
		Person p3 = null;
		System.out.println( p1.equals(p3));
		
		MyDate d = new MyDate(2017,10,7);
		System.out.println( p1.equals(d));
		
		
		//int a[] = null;
		//p1.aa(a);
		
		System.out.println("Over....");
		
	}
	
	
	
}

package cn.hncu.para2.v3;

public class Group {
	
//	public static void print(Person ps[]){
//		if(ps==null){
//			return;
//		}
//		for( Person p: ps){
//			System.out.println(p.toString());
//		}
//	}
	
	public static void print(Object objs[]){
		if(objs!=null){
			for(Object obj: objs){
				if(obj!=null){
					System.out.println(obj.toString());
				}
			}
		}
	}
	
	public static int indexOf(Object objs[], Object obj){
		/*
		if(objs!=null && obj!=null){
			for(int i=0; i<objs.length; i++){
				if(obj.equals(objs[i])){
					return i;
				}
			}
			return -1;
		}else{
			return -1;
		}
		*/
		
		if(objs!=null && obj!=null){
			for(int i=0; i<objs.length; i++){
				if(obj.equals(objs[i])){//工程上的相等用equals()判断且该方法通常要覆盖，，，同一个堆内存(地址捆绑)用==判断
					return i;
				}
			}
		}
		return -1;
	}
	
	public static Object[] group( Object ar1[], Object ar2[]){
		//※注意判断空指针与数组长度为0 两个条件的顺序不能颠倒
		if(ar1==null || ar1.length==0){ 
			return ar2;
		}
		if(ar2==null || ar2.length==0){
			return ar1;
		}
		
		//程序能够到达这里，ar1和ar2一定不为空
		Object ar[] = new Object[ar1.length + ar2.length];
		//把ar1[]数组中的元素拷到ar[]中
		for(int i=0;i<ar1.length;i++){
			ar[i] = ar1[i];
		}
		//把ar2[]数组中的元素拷到ar[]中
		int k=ar1.length;
		for(int i=0 ;i<ar2.length ; i++){
			ar[k++] = ar2[i];
		}
		return ar;
	}
	
	public static void main(String[] args) {
		Person p1 = new Person("Jack",22);
		Person p2 = new Person("Tom",23);
		Student s1 = new Student("张三", 30, "外贸");
		Student s2 = new Student("李四", 32, "理发");
		Person p = new Student("张飞",35,"杀猪");
		
		//int a[] = {1,3,5};
		Person ps[] = {p1,p2,s1,s2,p};
		print(ps);
		
		System.out.println("---------------");
		
		MyDate d = new MyDate(2017, 10, 7);
		Object objs[] = {p1,p2,s1,s2,p,d,null};
		print(objs);
		
		System.out.println("=====================");
		
		Person p0 = new Person("张三",0);
		int k = indexOf(objs,p0);
		if(k!=-1){
			System.out.println("找到:"+objs[k]);
		}else{
			System.out.println("没找到:"+p0);
		}
		
		System.out.println("********************");
		Object objs2[] = {  new Person("Alice",23),
				            new Person("Bob",22),
				            new Student("刘备", 33, "卖药"),
				            new Student("曹操", 34, "打仗"),
				            new MyDate(2008,8,8)
		};
		
		Object objs3[] = group(objs, objs2);
		print(objs3);
		
	}
}

2.抽象方法的作用:
  （1）.限制子类必须实现该方法。既然子类一定实现了该抽象方法， 那么通过抽象父类的

引用就一定可以调用该方法  ---运行时

  （2）.解决编译时多态。

3.抽象方法  用关键字:abstract

4.抽象类不能实例化

5.最终方法Finally，子类不能覆盖

package cn.hncu.para3;
/*
 * 抽象方法的作用:
 * 1.限制子类必须实现该方法。既然子类一定实现了该抽象方法，
 *   那么通过抽象父类的引用就一定可以调用该方法  ---运行时
 * 2.解决编译时多态。
 * 
 */

public abstract class CloseFigure {
	private String shape;
	
	/**
	 * 创建一个封闭图形
	 * @param shape图形形状
	 */
	public CloseFigure(String shape) {
		//super()
		this.shape = shape;
	}
	
	//抽象方法  用关键字:abstract
	public abstract double area();
	public abstract double perimeter();
	public abstract void bb();
	
	public void print(){
		System.out.println("一个"+shape+","+this.toString()+",面积:"+this.area()+",周长:"+this.perimeter());
	}
	
	//最终方法，子类不能覆盖
	public final void cc(){
		System.out.println("00000");
	}
}

package cn.hncu.para3;

public class CloseFigureEx {
	
	public static void main(String[] args) {
		//CloseFigure g = new CloseFigure();//WA: 抽象类不能实例化
		//Person p = new Student();
		CloseFigure g = new Rectangle2(100, 200);
		//System.out.println( g.area() );
		g.print();
		g.bb();
		
		System.out.println("------------");
		
		g = new Circle(10);
		//System.out.println( g.area() );
		g.print();
		
	}
}

6.一个类继承了抽象父类，那么父类中的抽象方法要全部把它实现，否则只能声明成

抽象类。

 7.如果一个类中包含抽象方法(没有方法体)，那么这个类必须声明成抽象类。

 抽象类不能实例化(new对象)。

8.抽象类是当作多态中的父类来用的。

package cn.hncu.para3;

/*
 * 1. 一个类继承了抽象父类，那么父类中的抽象方法要全部把它实现，
 *    否则只能声明成抽象类。
 * 2. 如果一个类中包含抽象方法(没有方法体)，那么这个类必须声明成抽象类。
 *    抽象类不能实例化(new对象)。
 * 3. 抽象类是当作多态中的父类来用的。
 */

public abstract class Rectangle extends CloseFigure{
	private int width;//宽
	private int height;//高
	public Rectangle(int width, int height) {
		super("矩形");
		this.width = width;
		this.height = height;
	}
	
	
	/**
	 * 如果子类要实现***功能如从配置文件中读取字体，请覆盖该方法
	 */
	public void aa(){
	}
	
	
	public Rectangle() {
		this(0,0);
	}
	
	public int getWidth() {
		return width;
	}
	public void setWidth(int width) {
		this.width = width;
	}
	public int getHeight() {
		return height;
	}
	public void setHeight(int height) {
		this.height = height;
	}
	
	@Override
	public String toString() {
		return "长度:" + width + ", 高度:" + height;
	}
	
	public double area(){
		return width*height;
	}
	public double perimeter(){
		return (width+height)*2;
	}
	
	public void bb(){
		aa();//设置字体,如果不设，则用默认字体
		System.out.println("11111111111");
	}
	
}

package cn.hncu.para3;

public class Rectangle2 extends Rectangle{

	public Rectangle2() {
		super();
	}

	public Rectangle2(int width, int height) {
		super(width, height);
	}

//	@Override
//	public void aa() {
//		System.out.println("设置字体...");
//	}

}

 

小练习

package cn.hncu.para3;

public class Circle extends CloseFigure{
	private int r;
	private static double PI=3.1416;
	
	public Circle(int r) {
		super("圆");
		this.r = r;
	}
	public Circle() {
		this(0);
	}
	public int getR() {
		return r;
	}
	public void setR(int r) {
		this.r = r;
	}
	
	
	@Override
	public String toString() {
		return "半径:" + r;
	}
	
	
	@Override
	public double area() {
		return PI*r*r;
	}

	@Override
	public double perimeter() {
		return 2*PI*r;
	}
	
	@Override
	public void bb() {
		System.out.println("1111111111");
	}
	
	
	
}