目录
十五、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: jian_study.Dog@2a139a55
d: jian_study.Dog@2a139a55
如果对于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