1. 包名 + 类名 = 类的全名 ; 查字典：java.lang包里面的类 。
2. 面向对象的三大基本特征：
（1）封装：代码的复用，屏蔽底层的细节。
（2）继承：代码的复用，功能的扩展。子类自动拥有父类的所有成员。（单继承）
（3）多态：（下一节详细介绍）。
3. 访问修饰符：
（1）private：只能在类中访问；
（2）default：在同一个包下的类能相互访问；
（3）protected：在同一个包下的类能相互访问，但如果调用的类是继承的关系，即便这两个类不在同一个包下也能访问；
（4）public：什么地方都可以访问。
4. 方法的重写（方法的覆盖，override / overwrite）
（1）发生在继承关系中。
（2）子类重写的方法和超类（父类）被重写的方法必须拥有相同的方法名，相同的返回值类型，相同的参数列表。
（3）访问修饰符可以不一样，但子类中重写的方法不能有比超类中被重写的方法更严格的访问修饰符。
class Animal{
String name;
//下面的方法返回值类型默认为default
void sleep(){
System.out.println("Animal is sleeping");
}
}
class Cat extends Animal {
//子类的sleep()方法的返回值类型不能比父类更严格
public void sleep(){
System.out.println(name + " is sleeping");
}
}
public class Md{
public static void main(String args[]){
Cat cat = new Cat();
cat.name = "tom";
cat.sleep();
}
}
5. super 指针：当前对象对父类对象的引用。
super.方法名() 在方法的重写中调用父类的方法。
super.成员变量：子类和父类成员变量同名的时候。
super(); 调用父类的构造方法。
创建子类对象时一定要先构造一个父类的对象，这样才可能拥有父类的所有成员。
创建对象一定要使用构造方法，java在创建子类对象的时候默认调用的是父类无参数的构造方法。
当子类的构造方法要调用父类的构造方法的时候，super() 一定要写在子类构造方法的第一句话。
（即：先有父亲再有儿子）
class Animal{
// 重写父类的构造方法，隐式无参数构造方法消失
public Animal(String name){
this.name = name;
}
String name;
//下面的方法返回值类型默认为default
void sleep(){
System.out.println("Animal is sleeping");
}
}
class Cat extends Animal {
public Cat(){
super("n"); //手动调用父类显式构造方法
}
//子类的sleep()方法的返回值类型不能比父类更严格
public void sleep(){
super.sleep(); //调用父类的方法要用super指针
System.out.println(name + " is sleeping");
}
}
public class Md{
public static void main(String args[]){
Cat cat = new Cat();
cat.name = "tom";
cat.sleep();
}
}
6. 方法的重载（overlode）。
（1）在同一个类中。
（2）重载的方法和被重载的方法必须拥有相同的方法名，可以拥有不同的返回值类型，但必须拥有不同的参数列表。
class T{
public static void add(int a , int b){
System.out.println(a + b);
}
public static int add(int a , int b , int c){
return a+b+c;
}
}
7. object 类：所有java类的根类，其中两个特殊的类是：
toString ：（1）System.out.println() 方法中会自动调用toString().
（2）在出现字符串连接符"+"时。
重写toString方法：
public class Ma {
public static void main(String args[]){
Person p = new Person();
p.name = "jim";
p.age = 21;
System.out.println(p);
}
}
class Person {
String name;
i nt age;
public String toString(){
return "name:" + this.name + ";age:" + this.age;
}
}
equals ： 指示其他对象是否与此对象“相等”。equals比较的是对象，“==”比较的是引用，是栈内的东西。
public class Ma {
public static void main(String args[]){
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2));
}
}
运行结果为true，这是因为String类是java自己定义的，所以java能识别。
如果新定义一个类Person，然后赋予参数name和age进行判别：
public class Ma {
public static void main(String args[]){
Person p1 = new Person("jim",11);
Person p2 = new Person("jim",12);
System.out.println(p1.equals(p2));
}
}
class Person {
public Person(String name , int age){
this.name = name ;
this.age = age ;
}
String name;
int age;
public boolean equals(Object obj){
Person p = (Person)obj;
if(this.name.equals(p.name))
{return true;}
else
{return false;}
}
}
8. 重写hashCode（哈希码）
在上面的Person类的最后加上：
public int hashCode(){
return this.name.hashCode();
}