标签：提取 取出 特性 pca main setname xtend 额外 区别
抽象类格式
abstract class 类名{}
方法没有方法体，即：没有{}
abstract public void eat();
public abstract void eat();
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
具体事物：猫，狗
共性：姓名，年龄，吃
有共性，所以可以提取出父类，但是由于子类对方法“吃”有不同的实现，所以，将方法“吃”定义为一个抽象方法，所以这个父类也就成了抽象类，这个父类的实现类都需要实现自己的特有的“吃”方法，才是一个可以被实例化的类，否则还是一个抽象类。
////定义抽象的动物类
public abstract class AnimalDemo {
//私有成员变量
private String name;
private int age;
public abstract void eat(); //抽象方法
//公有的get/set方法
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
//空参构造方法
public AnimalDemo(){}
//有参构造方法
public AnimalDemo(String name,int age){
this.age=age;
this.name=name;
}
}
//继承父类 并实现父类抽象方法
public class DogDemo extends AnimalDemo {
//空参构造方法
public DogDemo(){}
//两个参数的构造方法
public DogDemo(String name,int age){
//调用父类有参构造方法,并传参
super(name,age);
}
//重写父类抽象方法
public void eat(){
System.out.println("Dog eat");
}
}
//继承父类 并实现父类抽象方法
public class CatDemo extends AnimalDemo {
public CatDemo(){}
public CatDemo(String name, int age){
super(name,age);
}
public void eat(){
System.out.println("cat eat");
}
}
测试类
public class DemoTest {
public static void main(String[] args) {
AnimalDemo ad = new DogDemo("tom",2);//采用多态 父类引用指向子类对象
ad.eat();
System.out.println("name:"+ad.getName()+" "+"age:"+ad.getAge());
AnimalDemo aadd = new CatDemo("jack",3);
aadd.eat();
System.out.println("name:"+aadd.getName()+" "+"age:"+aadd.getAge());
}
}
接口用关键字interface表示
格式：interface 接口名 {} //不能使用class关键字
类实现结构用 implements关键字
格式：class 类名 implements 接口名{}
接口没有构造方法，即：接口不能实例化
只有接口和接口之间使用的是extends关键字，抽象类和接口之间，实现类和接口之间都是用的implements关键字。
成员变量
只能是常量
默认的修饰符public ， static ，final ，其中任何一个都可以省略，也可以全省略
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
普通类与普通类--extends
继承关系只能单继承，但是可以多层继承
普通类和抽象类--extends
继承关系，只能单继承，但是可以多层继承
普通类与接口，抽象类与接口--implements
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时是想多个接口，此时应该注意extends要写在前，implements写在后
接口与接口--extends
继承关系，可以单继承，也可以多继承
/*
猫狗案例,加入跳高的额外功能
分析：从具体到抽象
猫：
姓名,年龄
吃饭，睡觉
狗：
姓名,年龄
吃饭，睡觉
由于有共性功能，所以，我们抽取出一个父类：
动物：
姓名,年龄
吃饭();
睡觉(){}
猫：继承自动物
狗：继承自动物
跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
接口：跳高
部分猫：实现跳高
部分狗：实现跳高
实现；
从抽象到具体
使用：
使用具体类
*/
//定义跳高接口
public interface Jump {
public abstract void jump();
}
public class Dog extends Animal {
public void eat(){
System.out.println("狗啃骨头");
}
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
}
public class Cat extends Animal {
public void eat(){
System.out.println("猫捉老鼠");
}
public Cat(){}
public Cat(String name,int age){
super(name,age);
}
}
public class JumpDog extends Dog implements Jump{
public JumpDog(){}
public JumpDog(String name,int age){
super(name,age);
}
public void jump(){
System.out.println("狗可以跳");
}
}
public class JumpCat extends Cat implements Jump {
public JumpCat(){}
public JumpCat(String name,int age){
super(name,age);
}
public void jump(){
System.out.println("猫可以跳了");
}
}
//测试类
public class JumpTest {
public static void main(String[] args) {
Animal a = new Cat("tom",2);
System.out.println("name:"+a.getName()+" "+"age:"+a.getAge());
a.eat();
a.sleep();
System.out.println("----------------");
JumpCat jc = new JumpCat("加菲",2);
System.out.println("name:"+jc.getName()+" "+"age:"+jc.getAge());
jc.eat();
jc.jump();
jc.sleep();
System.out.println("----------------");
System.out.println("name:"+a.getName()+" "+"age:"+a.getAge());
a= new Dog("jerry",2);
a.eat();
a.sleep();
System.out.println("----------------");
JumpDog jg = new JumpDog("机械狗",2);
System.out.println("name:"+jg.getName()+" "+"age:"+jg.getAge());
jg.eat();
jg.jump();
jg.sleep();
}
}标签：提取 取出 特性 pca main setname xtend 额外 区别
原文地址：http://www.cnblogs.com/740810wt/p/6623924.html
