Java学习第十一天---------抽象类,抽象类的成员特点,接口

Java学习第十一天---------抽象类,抽象类的成员特点,接口

1.抽象类:在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
 抽象类的特点:
   a:抽象类和抽象方法必须用abstract关键字修饰
		抽象类格式:		abstract class 类名 {}
		抽象方法格式:	public abstract void eat();
	b:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
	c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
		用于子类访问父类数据时的初始化
	d:抽象类不能直接实例化那么,抽象类如何实例化呢?
		按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
	e:抽象类的子类
		要么是抽象类
		要么重写抽象类中的所有抽象方法
 抽象类的成员特点:
    a:成员变量:既可以是变量,也可以是常量。
	b:构造方法:有。用于子类访问父类数据的初始化。
	c:成员方法:既可以是抽象的,也可以是非抽象的。
案例:
  public abstract class AA {
    int num=100;
    public AA(){
        System.out.println("AA的构造");
    }
    public abstract void aa();
}
public class BB extends AA {
    public BB(){
        super();
        System.out.println("BB的构造");
    }

    @Override
    public void aa() {
        System.out.println("重写了父类的方法");
    }
}
public class MyTest2 {
    public static void main(String[] args) {
        //按照多态的方式 由具体的子类实例化,这也是多态的一种,抽象类多态
        AA aa=new BB();
        aa.aa();
        System.out.println(aa.num);
        BB bb=(BB)aa;
        System.out.println(bb.num);
    }
}
案例(抽象类猫狗案例):
  public abstract class Animal {
    String name;
    int age;
    public abstract void eat();
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼干");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }

}
public class MyTest {
    //抽象类练习猫狗案例
    //案例演示
    //	具体事物:猫,狗
    //	共性:姓名,年龄,吃饭
    public static void main(String[] args) {
        Animal an=new Cat();
        an.name="小咪";
        an.age=3;
        an.eat();
        ((Cat) an).catchMouse();
        System.out.println("==========================");
        Dog dog = new Dog();
        an=dog;
        an.name="旺财";
        an.age=5;
        an.eat();
        ((Dog) an).lookDoor();
    }
}
案例(老师):
  public abstract class Teacher {
    String name;
    int age;
    public abstract void teach();
}
public class Jichu extends Teacher {
    @Override
    public void teach() {
        System.out.println("基础班老师讲课");
    }
}
public class Jiuye extends Teacher {
    @Override
    public void teach() {
        System.out.println("就业班老师讲课");
    }
}
public class MyTest {
    public static void main(String[] args) {
        //抽象类练习老师案例
        //案例演示
        //	具体事物:基础班老师,就业班老师
        //	共性:姓名,年龄,讲课
        Teacher teacher=new Jichu();
        teacher.name="王老师";
        teacher.age=30;
        System.out.println(teacher.name);
        System.out.println(teacher.age);
        teacher.teach();
        System.out.println("==================================");
        Jiuye jiuye = new Jiuye();
        teacher=jiuye;
        teacher.name="李老师";
        teacher.age=45;
        System.out.println(teacher.name);
        System.out.println(teacher.age);
        teacher.teach();
    }
}
2.接口:实现额外功能
  接口特点
	a:接口用关键字interface表示		 格式: 	interface 接口名 {}
	b:类实现接口用implements表示	 格式:	class 类名 implements 接口名 {}
	c:接口不能实例化
		那么,接口如何实例化呢?
		按照多态的方式来实例化。
	d:接口的子类
		a:可以是抽象类。但是意义不大。
		b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
  接口成员特点
	成员变量;只能是常量,并且是静态的。
			默认修饰符:public static final
	构造方法:接口没有构造方法。
	成员方法:只能是抽象方法。
			默认修饰符:public abstract
  类与类,类与接口,接口与接口的关系
	a:类与类:
		继承关系,只能单继承,可以多层继承。
	b:类与接口:
		实现关系,可以单实现,也可以多实现。
		并且还可以在继承一个类的同时实现多个接口。
	c:接口与接口:
		继承关系,可以单继承,也可以多继承
  抽象类与接口的区别:
   成员区别
	抽象类:
		成员变量:可以变量,也可以常量
		构造方法:有
		成员方法:可以抽象,也可以非抽象
	接口:
		成员变量:只可以常量
		成员方法:只可以抽象	
  关系区别
	类与类
		继承,单继承
	类与接口
		实现,单实现,多实现
	接口与接口
		继承,单继承,多继承
 案例:
public class MyTest {
    public static void main(String[] args) {
        //接口:interface  用来定义一些额外的扩展功能,哪些事物想要具备这些功能,可以去实现这个接口,重写接口中的功能
        MyInterface myInterface=new DD();
        myInterface.show();
        myInterface.show2();
        System.out.println("============================");
        CC cc=new CC();
        AA aa=cc;
        aa.show();
        aa.show2();
        aa.show3();

    }
}
interface MyInterface{
    public abstract void show();
    public abstract  void  show2();
}

abstract class AA implements MyInterface{
    public abstract  void show3();
}

class CC extends AA{
    @Override
    public void show() {
        System.out.println("show方法实现了");
    }

    @Override
    public void show2() {
        System.out.println("show2方法实现了");
    }

    @Override
    public void show3() {
        System.out.println("show3方法实现了");
    }
}

class DD implements MyInterface{
    @Override
    public void show() {
        System.out.println("DD中show方法实现了");
    }

    @Override
    public void show2() {
        System.out.println("DD中show2方法实现了");
    }
}
案例:
动物类:姓名,年龄,吃饭,睡觉。
	动物培训接口:跳高
	猫继承动物类
	狗继承动物类
	部分猫继承猫类并实现跳高接口
	部分狗继承狗类并实现跳高接口

	通过抽象类测试基本功能。
	通过接口测试扩展功能。
public abstract  class Animal {
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫白天睡觉");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗趴着睡觉");
    }
}
public class gaofei extends Dog implements jumpInterface{
    @Override
    public void eat() {
        System.out.println("高飞狗吃的是牛排");;
    }

    @Override
    public void sleep() {
        System.out.println("高飞狗,在床上睡觉");
    }

    @Override
    public void jump() {
        System.out.println("高飞狗经过自己的学习,学会了跳高");
    }
}
public class jiafei extends Cat implements jumpInterface {
    @Override
    public void eat() {
        System.out.println("加菲猫吃鱼排");
    }

    @Override
    public void sleep() {
        System.out.println("加菲猫睡在沙发上");
    }

    public void catchMouse(){
        System.out.println("加菲猫抓老鼠");
    }


    @Override
    public void jump() {
        System.out.println("加菲猫学会了跳高");
    }
}
public interface jumpInterface {
    public abstract void jump();
}
public class lihua extends Cat{
    @Override
    public void sleep() {
        System.out.println("狸花猫睡在炕上");
    }

    @Override
    public void eat() {
        System.out.println("狸花猫爱吃火腿肠");
    }
}
public class wangcai extends Dog {
    @Override
    public void eat() {
        System.out.println("旺财喜欢吃肉包子");
    }

    @Override
    public void sleep() {
        System.out.println("旺财睡在院子里");
    }

    public void lookDoor(){
        System.out.println("旺财尽忠职守,看门");
    }
}
public class MyTest {
    public static void main(String[] args) {
        //通过抽象类测试基本功能。
        // 通过接口测试扩展功能。
        jiafei jiafei = new jiafei();
        Cat cat=jiafei;
        cat.name="加菲猫";
        cat.age=20;
        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.eat();
        cat.sleep();
        ((jiafei) cat).catchMouse();//jiafei.catchMouse();
        ((jiafei) cat).jump();//jiafei.jump();

        //使用接口来调用扩展功能
        jumpInterface jumpInterface=jiafei;
        jumpInterface.jump();

        System.out.println("============================");
        lihua lihua = new lihua();
        cat=lihua;
        cat.name="梨花猫";
        cat.age=3;
        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.eat();
        cat.sleep();
    }
}


已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页