Java学习 第三章面向对象 （下）

一.动态绑定和多态

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

1.要有继承  2.要重写  3.父类引用要指向子类对象

补充小例子

二.抽象类

用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修身一个方法时，该方法叫做抽象方法

含有抽象方法的类必须被声明为抽象类，抽象了必须被基础，抽象方法必须被重写

抽象类不能被实例化

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

abstract  class Animal{

private String name;

     Animal(String  name){ this.name=name;}

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

public abstract void enjoy();

}

class cat  extends  Animal{

private String eyesColor;

Cat(String n,String c){

super(n);

eyesColor=c;

public void  enjoy(){

System.out.println("猫叫声")；

}

}

}

三.Final 关键字

final的变量值不能够被修改

final的方法不能够被重写

final的类不能够被继承

四.接口（interface）

1.定义

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

例如： public interfere Runner｛

public static  final int  id=1;

public void start();

public void run();

public void stop();

｝

2.特性

（1）.接口可以多重实现；

（2）.接口声明的属性默认值为 public static final，也只能是public static final；

（3）.接口只能定义抽象方法，而且这些方法默认为public的，也只能是public的；

（4）.接口可以继承其它的接口，并添加新的属性和方法

   多个无关的类可以实现同一个接口；一个类可以实现多个无关的接口；与继承关系相似，接口与实现类之间存在多态性

3.定义Java类的语法格式

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

<declarations>

}

4.简单的小例子

public interface Singer {
public static final int  id=2;
String sex="f";

public void sing();

public void sleep();

}

interface  Painter{
public void paint();
public void run();
 }

class Stu implements Singer{

private  String name;

Stu(String name){
this.name=name;
}
// 实现接口中的方法
public void  sleep(){
System.out.println("Student  sleep");
}
public void  sing(){
System.out.println("Student  sing");
}
// 自定义自己的方法
public void  study(){
System.out.println("Student  sing");
}
}


class Teacher implements Painter,Singer{
// 实现接口中的方法
public  void  paint(){
System.out.println("Teacher  paint");
}

// 实现接口中的方法
public void  sleep(){
System.out.println("Teacher  sleep");
}
public void  sing(){
System.out.println("Teacher  sing");
}
// 自定义自己的方法
public  void  teach(){
System.out.println("Teacher  teach");
}
}

public class InterfaceTest  {
public static void main(String args[]){
// 父类引用指向子类对象，只可以方法父类中定义的属性和变量，对于子类中定义而父类中没有的方法是无法访问的，所以s1.study（）是不允许的
// Singer s1 定义了一个Singer对象引用，new Student("test") 实例化了一个Stu test，然后s1 指向了这个 Stu test
Singer s1=new Stu("test");
s1.sleep();
s1.sing();

Singer s2=new Teacher();
s2.sing();
s2.sleep();
// 强制类型转换，把父类对象转换成子类对象，这样可以访问 子类中的方法paint（）
// 在进行强类型转换的时候，我们要确保能够转换，只有当父类指向的实例是某个子类的对象的时候才可以转换成该类的对象
// 如果不能确定可以通过instanceof操作符进行判断  if(s2 is instanceof painter)
Painter p1=(Painter)s2;
p1.paint();
}
}