目录

十五、Object类

1.toString

2.equals

十六、对象转型（casting）

十七、动态绑定（多态）

十八、抽象类（abstract）

十九、final关键字

二十、接口

十五、Object类

Object类是所有java类的根基类

如果在类的声明中未使用extends关键字致命其基类，则默认基类为Object类，也就是说

public class Person {…}等价于public classPerson extends Object {…}

1.toString

Object类中定义有public String tuString()方法，其返回值是String类型，描述当前对象的有关信息

在进行String与其他类型数据的链接操作时（如：System.out.print(“info”+person)），将自动调用该对象类的toString()方法

可以根据需要在用户自定义类型中重写toString()方法

//测试类
public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        System.out.println("d: "+d);
        //等价于
         System.out.println("d: "+d.toString());
    }
}
class Dog {
}

输出结果：

d: [email protected]
d: [email protected]

如果对于Object中某些方法不满意可以自己在自己类中进行重写，例如：

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        System.out.println("d: "+d);
        //等价于
        System.out.println("d: "+d.toString());
    }
}
class Dog {
    public String toString(){
        return "HelloWorld!";
    }
}
//输出结果
d: HelloWorld!
d: HelloWorld!

2.equals

public boolean equals(Object obj)方法

提供定义对象是否相等的逻辑，使用格式：

x.equals(y)当x和y是同一个对象的应用时返回true，斗则返回false

jdk提供的一些类，如String，Date等，重写了OBject的equals方法，调用这些类的equals方法，x.equals(y)，当x和y所引用的对象是同一类对象且属性能容相等时（并不一定是相同对象），返回true，否则返回false

可以根据需要在用户自定义类型中重写equals方法

public class Test {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        Dog d2 = new Dog();

        System.out.println(d1 == d2);
        System.out.println(d1.equals(d2));

    }
}
class Dog {
}

输出结果：

false
false

可以查看javaAPI文档来查看输出为false的原因，这个时候就可以进行方法重写

public class Test {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        Dog d2 = new Dog();

        System.out.println(d1 == d2);
        System.out.println(d1.equals(d2));

    }
}
class Dog {
    public boolean equals(Object obj) {
        return true;
    }
}

再来看返回结果

false
true

这里只是说明系统方法也是可以重写的，并且进行了一个简单的举例

十六、对象转型（casting）

一个基类的引用类型变量可以“指向”其子类的对象

一个基类的引用不可以访问其子类对象新增的成员（属性和方法）。

可以使用引用变量instanceof类名来判断该引用型变量所指向的对象是否属于该类或该类的子类

子类的对象可以当作基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）

先看一个例子：

//新建一个基类
public class Animal {
    public String name;
    Animal(String name) {
        this.name = name;
    }
}

//新建一个子类Cat继承Animal基类
public class Cat extends Animal {
    public String eyesColor;
    Cat(String n, String c) {
        super(n);
        eyesColor = c;
    }
}

//新建一个子类Dog继承基类Animal
public class Dog extends Animal{
    public String funColor;
    Dog(String n,String c) {
        super(n);
        funColor = c;
    }
}

//测试类1
public class Test {
    public static void main(String args[]) {
        Animal a = new Animal("name");
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname", "black");
        //a的引用是否指向Animal
        System.out.println(a instanceof Animal);//true
        //c的引用是否指向Animal
        System.out.println(c instanceof Animal);//true
        //d的引用是否指向Animal
        System.out.println(d instanceof Animal);//true
        //a的引用是否指向Cat
        System.out.println(a instanceof Cat);//false
        // 父类引用指向子类对象，所以父类无法调用子类的furname属性，所以会报错
        a = new Dog("bigyellow","yellow");
        System.out.println(a.name);//bigyellow
        //System.out.println(a.furname);//error
        //a的引用知否指向Animal
        System.out.println(a instanceof Animal);////true
        //a的引用是否指向Dog，因为instanceof探测的是你实际当中是个什么类型，所以这里会返回true
        System.out.println(a instanceof Dog);//true
        //强制类型转换，所以下面会返回true
        Dog d1 = (Dog)a;
        System.out.println(d1.funColor);//yellow
    }
}

//测试类2
public class Test {
    public static void main(String args[]) {
        Test test = new Test();
        Animal a = new Animal("name");
        Cat c = new Cat("catname", "blue");
        Dog d = new Dog("dogname", "black");
        test.f(a);
        test.f(c);
        test.f(d);
    }
    //定义一个方法
    public void f(Animal a) {
        System.out.println("name: "+a.name);
        if(a instanceof Cat) {
            Cat cat = (Cat)a;
            System.out.println(" "+cat.eyesColor+" eyes");
        }else if(a instanceof Dog) {
            Dog dog = (Dog)a;
            System.out.println(" "+dog.funColor+" fur");
        }
    }
}

/*输出结果
name: name
name: catname
 blue eyes
name: dogname
 black fur
 */

十七、动态绑定（多态）

动态绑定是指“在执行期间（而非编译其间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法”

看一个例子

//新建一个基类
public class Animal {
    public String name;
    Animal(String name) {
        this.name = name;
    }
    public void enjoy() {
        System.out.println("叫声....");
    }
}

//新建一个子类Cat继承Animal基类
public class Cat extends Animal {
    public String eyesColor;
    Cat(String n, String c) {
        super(n);
        eyesColor = c;
    }
    public void enjoy() {
        System.out.println("猫叫声...");
    }
}

//新建一个子类Dog继承基类Animal
public class Dog extends Animal{
    public String funColor;
    Dog(String n,String c) {
        super(n);
        funColor = c;
    }
    public void enjoy() {
        System.out.println("狗叫声...");
    }
}

//Lady类
public class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {
        this.name = name;
        this.pet = pet;
    }
    public void myPetEnjoy() {
        pet.enjoy();
    }
}

//测试类
public class Test {
    public static void main(String args[]) {
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname", "black");
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2", d);
        l1.myPetEnjoy();
        l2.myPetEnjoy();
    }
}

输出结果为：

猫叫声...
狗叫声...

上面的例子中，根据lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法

Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname", "black");

Lady l1 = new Lady("l1",c);

上面三行代码的内存分配图如下：

enjoy方法有三个，分别是animal的，dog的和cat的，动态绑定就是调用的实际new的那个方法，指向的就是那个方法。也就是l1指向的实际方法应该是cat的那个enjoy方法。

当后期需要扩展的时候，只需要加一个扩展类，然后在test类中new一个扩展对象出来并使用对象.方法的方式引用即可，扩展性非常强

多态的存在有三个必要条件：

1）要有继承

2）要有重写

3）父类引用指向子类对象

十八、抽象类（abstract）

使用abstract关键字来修饰一个类的时候，这个类叫做抽象类；同样的，使用abstract来修饰一个方法时，这个方法叫做抽象方法。

含有抽象方法的类必需被声明为抽象类，抽象类必需被继承，抽象方法必需被重写。

抽象类不能被实例化

抽象方法只需声明，而不需要实现

//修改基类
abstract class Animal {
    public String name;
    Animal(String name) {
        this.name = name;
    }
    /*
    public void enjoy() {
        System.out.println("叫声....");
    }
    */
    public abstract void enjoy();
}

由于在之前的那个例子中，基类的方法是没有被实现的，这个时候就可以使用abstract关键字将基类的方法和类变为抽象方法、抽象类，只是被继承，强制子类必需重写方法

十九、final关键字

final修饰的变量的值不能够被改变

final修饰的方法不能够被重写

final修饰的类不能够被继承

//示例代码
public class TestFinal {
    public static void main(String[] args) {
        T t = new T();
        t.i = 9;
    }

}
class T {
    final int i = 0;
}

如上的代码中会报错，因为在T类中已经定义了final int i的值，所以在new出来的新的t中是无法对i的值进行修改的，即便把t.i改为0也会报错。因为在执行过程中是将0重新赋值给了t.i

二十、接口

接口（interface）是抽象方法和常量值的定义的集合

本质上讲，接口是一种特殊的抽象类，这种抽象类中值包含常量和方法的定义，而没有变量和方法的实现

接口定义举例：

public interface Runner {
    public static final int id = 1;
    public void start();
    public void run();
    public void stop();
}

接口特性：

• 接口可以多重实现
• 接口中声明的属性默认为public static final的；也只能是public static final的
• 接口只能定义抽象方法，而且这些方法默认为public的，也只能是public的
• 接口可以继承其他的接口，并添加新的属性和抽象方法
• 多个无关的类可以实现同一个接口
• 一个类可以实现多个无关的接口
• 与继承关系类似，接口与实现类之间存在多态性

定义java类的语法格式：

< modifier > class < name > [ extends < superclass > ] [ implements < interface > [ , <interface> ] * ] {
     < declarations > *
}

看个例子：

//定义一个接口类Singer
interface Singer {
    public void sing();
    public void sleep();
}

//再定义一个接口类
interface Painter {
    public void paint();
    public void eat();
}

//定义students类实现singer接口
public class Students implements Singer {
    private String name;
    Students(String name) {
        this.name = name;
    }
    public void study() {
        System.out.println("studying...");
    }
    public String getName() {
        return name;
    }
    public void sing() {
        System.out.println("student is singing...");
    }
    public void sleep() {
        System.out.println("student is sleeping..");
    }
}

//定义类实现singer和painter类
class Teacher implements Singer,Painter{
    private String name;
    public String getString() {
        return name;
    }
    Teacher(String name) {
        this.name = name;
    }
    public void teach() {
        System.out.println("teaching");
    }
    public void sing(){
        System.out.println("teacher is singing");
    }
    public void sleep() {
        System.out.println("teacher is sleeping");
    }
    public void paint() {
        System.out.println("teacher is painting");
    }
    public void eat() {
        System.out.println("teacher is eating");
    }
}

//调试输出的测试类
public class test {
        public static void main(String args[]) {
            Singer s1 = new Students("s1");
            s1.sing();
            s1.sleep();
            Singer s2 = new Teacher("s2");
            s2.sing();
            s2.sleep();
            Painter p1 = (Painter)s2;
            p1.paint();
            p1.eat();
        }
}

输出结果：

student is singing...
student is sleeping..
teacher is singing
teacher is sleeping
teacher is painting
teacher is eating