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();
}
}
4188
