——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
1:抽象类
(1)什么是抽象类
把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点
抽象类的特点和使用
抽象类不能实例化对象，不能new
为什么不能new对象，抽象方法无法调用
定义子类继承抽象类，子类重写抽象方法，建立子类对象
如果子类只重写了部分抽象方法，子类还是一个抽象类
子类如果需要建立对象，全部重写父类抽象方法
abstract class Animal
{
public abstract void eat();
public abstract void sleep();
}
//定义Animal类的子类cat,继承Animal，重写抽象方法
class Cat extends Animal
{
//重写抽象方法，去掉abstract关键字，加上{}
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep(){
System.out.println("睡觉");
}
}
class AbstractClassDemo1
{
public static void main(String[] args)
{
//创建子类Cat对象
Cat c = new Cat();
c.eat();
}
}
(3)抽象类的成员特点：
A:成员变量
有变量，有常量
B:构造方法
有构造方法
C:成员方法
有抽象，有非抽象
(4)抽象类的练习
A:猫狗案例练习
abstract class Animal
{
public abstract void eat();
}
class Dog extends Animal
{
public void eat(){
System.out.println("狗吃热狗");
}
}
class Cat extends Animal
{
public void eat(){
System.out.println("猫吃鱼");
}
}
class abstractTestAnimal
{
public static void main(String[] args)
{
Cat c = new Cat();
c.eat();
Dog d = new Dog();
d.eat();
}
} B:老师案例练习
/*
老师案例
具体事物：基础班老师，就业班老师
共性：讲课。
有2个事物，基础老师，就业老师 有共性，上课
如果是老师，必须具备上课功能
共性抽取形成一个父类，上课方法
规定了，我这个类所有子类，必须有上课功能，怎么上课，讲的是什么，由子类重写决定
*/
//定义老师的抽象类，规定上课功能，没有具体实现
abstract class Teacher
{
public abstract void teacher();
}
//定义基础老师
class JavaSeTeacher extends Teacher
{
public void teacher(){
System.out.println("讲的是Javase");
}
}
//定义就业老师
class JavaEeTeacher extends Teacher
{
public void teacher(){
System.out.println("讲的是Javaee+三大框架 SSH");
}
}
class AbstractClassTestTeacher
{
public static void main(String[] args)
{
Teacher t = new JavaSeTeacher();
t.teacher();
t = new JavaEeTeacher();
t.teacher();
//System.out.println("Hello World!");
}
}
(5)抽象类的几个小问题
A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
为了不让创建对象
C:abstract不能和哪些关键字共存
private 抽象本质覆盖这个方法，父类私有了，子类不知道父类中的方法
final final修饰方法，不能覆盖，抽象方法就是覆盖的
static 静态修饰可以类名直接调用，抽象方法没有主体
2:接口
(1)什么是接口：
当一个抽象类，类中的方法全部是抽象方法的时候，这个抽象类换了一个更贴切的名词叫做接口。
(2)接口的特点：
A:接口用关键字interface修饰
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract
(4)类与类,类与接口,接口与接口
A:类与类
继承关系，只能单继承，可以多层继承
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口
C:接口与接口
继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别
A:成员区别
抽象类：可以有非抽象方法
接口：必须都是抽象方法
B:关系区别:
类与类：继承
类与接口：实现
接口与接口：继承
C:设计理念不同
抽象类：is a，抽象类中定义的是共性功能。
接口：like a，接口中定义的是扩展功能。
(6)练习：
A:猫狗案例，加入跳高功能
/*
猫狗案例,加入跳高和算数的额外功能
猫可以跳高 -- 额外
狗算数 -- 额外
猫和狗是有共性的 -- 抽取父类，抽象类
额外功能，定义在接口中
*/
//定义跳高接口，谁有这个额外功能，谁实现接口
interface Jump
{
public abstract void jump();
}
//定义计算的接口，谁有这个额外功能，谁实现接口
interface Arithmetic
{
public abstract void arithmetic();
}
abstract class Animal
{
public abstract void eat();
}
//定义能计算的狗，是动物中的一种，同时自己额外计算
class ArithmeticDog extends Animal implements Arithmetic
{
public void eat(){
System.out.println("狗吃热狗");
}
public void arithmetic(){
System.out.println("狗在算数");
}
}
//定义能跳高的猫，是动物中的一种，同时自己额外跳高
class JumpCat extends Animal implements Jump
{
public void eat(){
System.out.println("猫吃鱼");
}
public void jump(){
System.out.println("猫在跳高");
}
}
class Cat extends Animal
{
public void eat(){}
}
class Dog extends Animal
{
public void eat(){}
}
class InterfaceTestAnimal
{
public static void main(String[] args)
{
JumpCat jc = new JumpCat();
jc.eat();
jc.jump();
ArithmeticDog ad = new ArithmeticDog();
ad.eat();
ad.arithmetic();
}
}