菜鸡自学JAVA坎坷路day.6（import的使用，extends，override）

1.包机制（package）：

域名倒着写。

实例说明如下：

/**
 * import的使用方法
 * author ：Wang
 * 
 * 
 */
package cn.wang;//包必须是非注释语句的第一句

import project02.user;//先是包名后是类名"包名.*"是全部导入，导入的这个包必须是public类型的才行    同一个包内可以直接使用里面的类
import java.util.Date;
import java.sql.*;//他和上面那一行都有Date这个类
import static java.lang.Math.*;//导入Math的所有静态属性；

public class testImport {
	public static void main(String[] args) {
		user u2 = new user();
		
		project02.testClass u3 = new project02.testClass();//要是没有导入的话就要指明这个类的地址
		
		Date d = new Date();//这时候会默认调用指向明了的java.util.Date
		
		java.util.Date d2 = new java.util.Date();//这样就可以清楚的说明调用的是哪一个类
		
		System.out.println(PI);//因为导入了静态的他      所以不用加前缀了
	}

}

2.面向对象的三大特征：

这章的学习方法：温新而知故

（1）.继承（extends）

注意：Java的接口可以多继承，但是他的类只能单继承；

每个类都默认为是Object的子类；（类一般首字母大写），可以在选中类以后用crtl加T可以看一个类的关系（继承结构）；

A  instanceof B 判断A是不是B的实例对象；

package cn.wang;
/**
 * 
 * 测试extends
 * @author HP
 *
 */

public class Person {
	String name;
	int age;
	
	public void rest() {
		System.out.println("我想要休息一会。");
	}
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "wangtong";
		stu.rest();
		System.out.println(stu.name);
		System.out.println(stu instanceof Person);
		System.out.println(stu instanceof Student);//instanceof   判断这个对象就是不是Student类的实例化；
	}

}

class Student extends Person{
	int height;
	
	public void study() {
		System.out.println("学习两个小时");
	}
}

3.重写（override）

package cn.wang;
/**
 * 测试重写
 * @author Wang
 *
 */

public class TsetOverride {
	public static void main(String[] args) {
		House a = new House();
		a.stop();//调用父类的stop（）
		a.run();//调用自己重写的run（）
		
	}
}

class Vehical{
	public void run() {
		System.out.println("滴滴滴   的跑");
	}
	
	public void stop() {
		System.out.println("刹车");
	}
	
	public Person passenger() {//直接调用一个包下面的Person类
		return new Person();
	}
}

class House extends Vehical{
	public void run() {//重写父类的run
		System.out.println("策马奔腾");
	}
	
	public Student passenger() {//这里重写的返回值可以是Person的子类Student而不能是Person的父类Object；
		return new Student();
	}
}

4.Object类的toString

package cn.wang;
/**
 * 测试Object
 * @author Wang
 *
 */

public class TestObject {
	public static void main(String[] args) {
		Object  obj = new Object();
		System.out.println(obj.toString());
		/* 这个是tostring（）的源码，作用就是打印他的地址结果为java.lang.Object@161cd475，源码也可以被重写
		 * public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }*/
	} 
}

5.equals

package cn.wang;
/**
 * equals的测试与重写
 * @author Wang
 *
 */

public class TestEquals {
	public static void main(String[] args) {
		
		User u1 = new User(1,"wang");
		User u2 = new User(1,"wang");
		
		System.out.println(u1.equals(u2));
		System.out.println(u1 == u2);//==相等的条件是看他们的地址是否相等  
		/*
	 public boolean equals(Object obj) {//这是equals的源码  默认的是与==一样的判断地址	
        return (this == obj);
    }
		 */
		
	}	
	

}

class User{
	int id;
	String name;
	
	public User(int id ,String name) {
		this.name = name;
		this.id = id;
	}


public boolean equals(Object obj) {//但在我们的实际开发中，通常会认为两个对象的内容相等时，则两个对象相等，equals返回true。对象内容不同，则返回false  所以对他进行重写
		
		if(this == obj) //如果地值相等肯定就是相等的
			return true;
		
		User other = (User)obj;//将传过来的对象强制转化成User类型的对象  因为  你的重写是为User重写的传进来的对象肯定是User类型的
		
		if(id == other.id) {
			return true;
		}
		return false;//注意这个要返回的代表整个函数的返回要是没有就报错；
		
	}
}

注意： 请仔细阅读注解；

6.继承树的追溯：super（）

/**
 * 测试super和继承树的追溯；
 * @author Wang
 *
 */

public class TestSuper {
	public static void main(String[] args) {
		Child C = new Child();//构造Child类的时候就是先构造他的根类Object然后构造Father最后构造自己    和static的初始化块（对类进行初始化）一样
		C.run();
	}
}

class Father {
	Father(){
		System.out.println("FatherClass Construct.");
	}
	
	public void run() {
		System.out.println("Father Run");
	}
	
}

class Child extends Father{
	
	Child(){
		super();//构造方法的第一句总是他   不管你写不写
		System.out.println("ChildClass Contruct.");
	}
	
	public void run() {
		super.run();//调用父类中被子类override的run();
		System.out.println("Child Run");
	}
}