J2SE基础摘要——面向对象

成员变量默认初始化值：

引用

对象的创建与使用

构造方法

约定俗成的命名规则

类的首字母大写
变量名和方法名的首字母小写
运用驼峰标识

内存解析小例子

对于test.change2(d1);这句而言，系统会给局部变量b分配栈内存，然后将d1的值赋给b,此时b和d1同时指向堆内存中的同一个对象，然后执行change2的函数体，在堆内存中生成一个新的BirthDate对象，并且b的引用指向这个对象，之后函数体执行完毕，栈内存释放b,在堆内存中原本b指向的BirthDate对象没有任何引用指向它，随后在某个时候，系统的垃圾回收器回收这个对象。

方法重载

方法名相同，参数不同

this关键字

在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
this可以看作一个变量，它的值是当前对象的引用。

static关键字

类中，用static声明的成员变量为静态成员变量，为类变量，对于该类所有对象，static成员变量只有一份。
用static声明的方法为静态变量，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。

package和import

package语句左右为Java原文件第一条语句。
包（package）机制，解决类的命名冲突问题。
访问同一包内的类不需要引入。

J2SDK中主要的包介绍

访问控制

继承

子类比父类大，子类对象包含父类对象

方法的重写（override）

在子类中可以根据需要对从基类中继承来的方法进行重写。
重写方法必须和被重写的方法具有相同的方法名称、参数列表和返回类型。
重写方法不能使用比被重写方法更严格的访问权限。

重写最好用复制粘贴函数名，防止出错，调bug会很蛋疼。

super关键字

和this一样，super实质也为指针，new一个子类对象，在堆内存中也有this指针和super指针，this指向子类对象本身，super指向子类对象中的父类对象。

继承中的构造方法

class SubClass extends SuperClass {
    private int n;
    SubClass(int n) {
        this.n = n;
    }
}

上述写法相当于下面写法：

class SubClass extends SuperClass {
    private int n;
    SubClass(int n) {
        super();
        this.n = n;
    }
}

若SuperClass中没有无参数为空的构造方法（即自己定义了参数不为空的构造方法，而没有定义参数不为空的构造方法，此时编译器不会生成默认参数为空的构造方法），则编译出错。

API文档查询

学会查询API文档，它是Java编程的影子。

Object类之toString方法

Object类是左右Java类的根基类
如果所在类声明中未使用extends关键字指明其基类，则默认基类为Object类

Object类的toString方法：

class TesttoString 
{
    public static void main(String[] args) 
    {
        Dog d = new Dog();      
        System.out.println("d->" + d);
    }
}

class Dog
{}

class TesttoString 
{
    public static void main(String[] args) 
    {
        Dog d = new Dog();

        System.out.println("d->" + d);
    }
}

class Dog
{
    public String toString() {
        return "i am a dog!";
    }
}

hashcode解释

Object类之equals方法

public class TestEquals 
{
    public static void main(String[] args) {

        Cat c1 = new Cat("kitty", 1);
        Cat c2 = new Cat("kitty", 1);

        System.out.println(c1 == c2); // false
        System.out.println(c1.equals(c2)); //true,若注释重写的equals方法，则为false
    }
}

class Cat
{
    private String name;
    private int color;

    public Cat(String name, int color) {
        this.name = name;
        this.color = color;
    }

    public boolean equals(Object obj)
    {
        if(obj == null)
            return false;
        else 
        {
            if(obj instanceof Cat)
            {
                Cat c = (Cat)obj;
                if(this.name == c.name && this.color == c.color)
                {
                    return true;
                }
            }
        }
        return false;
    }
}

String类重写了equals方法

对象转型（casting）

内存图：

代码：Animal a = new Dog(“““);
a 实际能看到的部分为Dog对象中的Animal对象。（1线所指）
对于子类的属性和方法，是看不到的。

动态绑定和多态

举例：Dog、Cat继承Animal；三者都有各自的play方法。
代码：Animal a = new Dog(“““);
虽然引用a只能看到Dog对象的父类对象，但在调用play方法时，系统会根据new出的实际对象，将指向方法play的指针动态绑定到子类重写的方法。

多态的三个条件：
1.要有继承
2.要有重写
3.父类引用指向子类对象（new哪个子类对象，实际就调用哪个对象的方法）

抽象类

final关键字

接口（interface）

接口中无论写不写abstract，所有的方法都是abstract。