java基础8_对象转型_接口

package java基础;
public class TestCasting {
private String cast = "hi cast";
public String getCast() {
return cast;
}
public void setCast(String cast) {
this.cast = cast;
}
public static void main(String[] args) {
TestCasting c = new TestCasting();
Object obj = c;//Object类是所有类的根基类，一个根基类的引用可以指向其子类的对象
//System.out.println(obj.getCast());//一个根基类的引用访问不到其子类对象新增加的属性和方法
Cat cat = c.new Cat();//通过外部类的引用去new一个内部类对象
TestCasting t = cat;//子类赋值给父类，或者说父类引用指向子类对象
System.out.println(t.cast);//访问父类自己的属性
//System.out.println(t.name);//一个根基类的引用访问不到其子类对象新增加的属性和方法

if(cat instanceof TestCasting) {//可以使用引用变量 instanceof 类名 来判断该引用对象所指向的对象是否属于该类或其子类

}
TestCasting t1 = cat;//向上转型，基类引用指向子类对象
Cat c1 = (Cat)c;//向下转型，子类引用指向基类对象
}
public TestCasting() {}

class Cat extends TestCasting{//Cat是TestCasting的内部类并且继承TestCasting类
private String name;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Cat(){}
}
}

package java基础;
//测试多态，动态绑定;  1、要有继承;2、要有重写;3、父类引用指向子类对象;满足这三个条件就实现了多态
public class TestPolymoph {
public static void main(String[] args) {
//Pig p = new Pig("lily","blue");//抽象类不能实例化对象
Horse h = new Horse("horsename","blue");
        Bird b = new Bird();
        Lady lady = new Lady();
        lady.myPetEnjoy(h);//传递一只马过去;动态绑定 Animal pet = h，实际执行h重写的方法
        lady.myPetEnjoy(b);//传递一只鸟过去;动态绑定 Animal pet = b，实际执行b重写的方法
        
        final int f = 2;//final 最终的，最后的，她修饰的变量不能修改，final修饰类，类不能被继承//修饰方法不能被重写
        //f = 3;//error，final的变量的值不允许修改
}
}


//抽象封装一个动物类,abstract修饰抽象，修饰类为抽象类，修饰方法为抽象方法
abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public Animal(){}
//public void enjoy(){ System.out.println("En en叫声......"); } //这种写法，不会强制提醒子类重写此方法
public abstract void enjoy();//一个抽象的方法，对行为的抽象，表示动物有这种行为，但是不知道具体是什么行为
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//猪继承动物
abstract class Pig extends Animal {
private String eyesColor;//有自己眼睛的颜色，自己的属性
public Pig(String n, String c) {
super(n);
eyesColor = c;
}
public abstract void sleep();//含有抽象方法的类必须是抽象类，抽象类必须被继承，抽象方法必须被重写，抽象类不能实例化对象
}
//马继承动物
class Horse extends Animal {
private String furColor;
Horse(String n, String c) {
super(n);
furColor = c;
}
public void enjoy() {//重写父类的方法
System.out.println(this.getName()+"喜欢奔跑......"+"我的毛颜色："+this.furColor);
}
}


//鸟继承动物
class Bird extends Animal {
Bird() {
super("bird");
}
@Override
public void enjoy() {//重写父类的方法
System.out.println(this.getName()+"喜欢唱歌，鸟叫声......");
}
}


//女士类
class Lady {
public void myPetEnjoy(Animal pet) {
pet.enjoy();
}
}


//interface定义一个接口，接口（interface）是抽象方法和常量值的定义的集合，从本质上讲，接口是一种特殊的抽象类
interface Runner {
private String ha;//error，接口里不能定义成员变量
public String method() {System.out.println("视图在接口里定义方法的实现");}//error，接口中没有方法的实现
int f = 9;//可以定义常量，该常量默认是public static final的
public String mymethod();//定义方法

}