010Java知识点小结--抽象类、接口

1.格式：

abstract class 类名 {}

2.特点：

1)抽象类和抽象方法必须用abstract关键字修饰

2)抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类

3)抽象类不能实例化

因为它不是具体的。

抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?
用于子类访问父类数据的初始化

4)抽象的子类

a:如果不想重写抽象方法，该子类是一个抽象类。

b:重写所有的抽象方法，这个时候子类是一个具体的类。

抽象类的实例化其实是靠具体的子类实现的。是多态的方式。

3.抽象类的成员特点：

成员变量：既可以是变量，也可以是常量。

构造方法：有。 用于子类访问父类数据的初始化。

成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：
A:抽象方法 强制要求子类做的事情。
B:非抽象方法 子类继承的事情，提高代码复用性。

4.abstract不能和哪些关键字共存?

1)private 冲突

2)final 冲突

3)Static 无意义

5.接口特点

接口用关键字interface表示

格式：interface 接口名 {}

类实现接口用implements表示

格式：class 类名 implements 接口名 {}

6.接口成员特点

1）成员变量： 只能是常量

默认修饰符 public static final

2）构造方法：没有

因为接口主要是扩展功能的，而没有具体存在

3）成员方法： 只能是抽象方法

默认修饰符 public abstract

所有的类都默认继承自一个类：Object。
类Object 是类层次结构的根类。每个类都使用 Object 作为超类。

7.类与类,类与接口以及接口与接口的关系

1)类与类

继承关系，只能单继承，但是可以多层继承

2)类与接口

实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

3)接口与接口

继承关系，可以单继承，也可以多继承

8.抽象类和接口的区别

1)成员区别

抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法

接口 常量;抽象方法

2)关系区别

类与类 继承，单继承

类与接口 实现，单实现，多实现

接口与接口 继承，单继承，多继承

3)设计理念区别

抽象类 被继承体现的是：”is a”的关系。共性功能

接口 被实现体现的是：”like a”的关系。扩展功能

9.形式参数和返回值问题

返回值类型：

1）基本类型:

2）引用类型：

类作为返回值：返回的是该类的对象

抽象类作为返回值：返回的是该抽象类的子类对象

接口作为返回值：返回的是该接口的实现类的对象

10.链式编程。

每次调用完毕方法后，返回的是一个对象。

11.今天练习过程中出现的错误：有些是经常出现的错误，比如：变量引用方法时方法名后面没有加括号、全角逗号、写太快this.name = name只写了一半等。

/*用猫狗案例，练习抽象类*/

abstract class Animal
{
private String name;
private int age;
public Animal(){}
public Animal(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public abstract void eat();//抽象方法，注意后面不用{}。
public  void show(){
System.out.println("名字叫：" + name + ",年龄为:" + age);
/*System.out.println("名字叫：" + name + ",年龄为:" + age + this.eat());//错误: 此处不允许使用 '空' 类型.原意是想把姓名年龄和行为一起打印出来，但忽略了eat()本身就是个打印方法，返回值类型为空*/
}
}

class Dog extends Animal
{
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("爱吃肉骨头");
}
}
class Cat extends Animal
{
public Cat(){}
public Cat(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("爱吃鱼");
}
public void playGame(){
System.out.println("玩毛线，抓蝴蝶");
}
}

class Test1
{
public static void main(String[] args){
Animal a = new Dog("阿黄",2);
a.show();
a.eat();
a.setName("小黑");
a.setAge(2);
a.show();
a.eat();
Animal b = new Cat("小花",3);
b.show();
b.
4000
eat();
/*尝试b.playGame();这个编译时就不会通过，因为多态编译是先看左边，Animal类的a无法调用Cat类方法playGame()。*/
Cat c = (Cat)b;
c.show();
c.eat();
c.playGame();//强转成子类Cat类就可以了。

}
}

/*
猫狗案例,加入跳高的额外功能

分析：从具体到抽象
猫：
姓名,年龄
吃饭，睡觉
狗：
姓名,年龄
吃饭，睡觉

由于有共性功能，所以，我们抽取出一个父类：
动物：
姓名,年龄
吃饭();
睡觉(){}

猫：继承自动物
狗：继承自动物

跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
接口：
跳高

部分猫：实现跳高
部分狗：实现跳高
实现；
从抽象到具体

使用：
使用具体类
*/
//定义跳高接口
interface Jumpping{
public abstract void jump();
}
interface Counting{//作为练习自己多添加了一个数数功能
public abstract void count();
}
abstract class Animal
{
private String name;
private int age;
//构造方法
public Animal(){}
public Animal(String name,int age){
this.name = name;/*this.name;//错误：不是语句。赋值语句忘写了后半句*/
this.age =age;/*this.age;//错误：不是语句*/
}
//定义抽象方法,吃饭
public abstract void eat();
//定义非抽象方法,睡觉
public void sleep(){
System.out.println("睡觉觉");
}
//set\get方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
//定义猫类
class Cat extends Animal{
public Cat(){}
public Cat(String name, int age){
super(name,age);
}
public void eat(){
System.out.println("猫吃鱼");
}
}
//定义狗类
class Dog extends Animal{
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("狗吃肉");
}
}
//跳高功能的猫
class JumpCat extends Cat implements Jumpping{
public JumpCat(){}
public JumpCat(String name,int age){
super(name,age);/*super(nam,age);//打字要细心*/
}
public void jump(){
System.out.println("它是会跳高的小猫咪");
}
}
//会表演跳高和数数的狗狗
class ShowDog extends Dog implements Jumpping,Counting{   /*同时实现两个功能。类与接口可以多个实现*/
public ShowDog(){}
public ShowDog(String name,int age){
super(name,age);
}
public void jump(){
System.out.println("它是会跳高的小狗狗");
}
public void count(){
System.out.println("它是会数数的狗狗");
}
}
//主方法
class InterfaceDemo
{
public static void main(String[] args){
JumpCat jc = new JumpCat("小白",4);
jc.eat();
jc.sleep();
System.out.println("它的名字叫"+jc.getName()+"，它的年龄是："+jc.getAge());
jc.jump();
ShowDog sg = new ShowDog();/*ShowDog sg = new ShowDog;//调用方法和定义类时经常会忘记写括号，要留神*/
sg.setName("小黑");
sg.setAge(5);
sg.eat();
sg.sleep();
System.out.println("它的名字叫"+sg.getName()+"，它的年龄"+sg.getAge());
/*System.out.println("它的名字叫"+sg.getName()+"它的年龄"+sg.getAge));//错误找不到符号。getAge方法的括弧又忘了*/
sg.jump();
sg.count();
}
}

/*
教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
*/

//建立学英语功能接口
interface SpeakEnglish{
public abstract void speak();/*public abstract void speak(){};//错误：接口抽象方法不能带有主体*/
}
//建立人抽象类
abstract class Person{/*abstract Person // 只顾写abstract，忽略了class*/
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public abstract void  eat();
public  void sleep(){
System.out.println("人人都睡觉");
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void getAge(int age){
this.age = age ;/*this.age;//错误：不是语句。忘记赋值*/
}
public int getAge(){
return age;
}
}
//运动员抽象类
abstract class Player extends Person{
public Player(){}
public Player(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("喝豆奶吃鸡腿");
}
public abstract void study();
}
//教练抽象类
abstract class Coath extends Person{
public Coath(){}
public Coath(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("喝牛奶吃牛排");
}
public abstract void teach();
}
//乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish{
public PingPangPlayer(){}
public PingPangPlayer(String name,int age){
super(name,age);
}
public void study(){
System.out.println("学习挥拍发球接球");
}
public void speak(){
System.out.println("会说英语");/* System.out.println("会说英语") //忘记分号*/
}
}
//篮球运动员具体类
class BasketBallPlayer extends Player{
public BasketBallPlayer(){}
public BasketBallPlayer(String name,int age){
super(name,age);
}
public void study(){
System.out.println("学习运球传球投篮");
}
}
//乒乓球教练具体类
class PingPangCoath extends Coath implements SpeakEnglish{
public PingPangCoath(){}
public PingPangCoath(String name,int age){
super(name,age);
}
public void teach(){
System.out.println("教授握拍调球的方法");
}
public void speak(){
System.out.println("会说英语");
}
}
//篮球教练具体类
class BasketBallCoath extends Coath{
public BasketBallCoath(){}
public BasketBallCoath(String name,int age){
super(name,age);
}
public void teach(){
System.out.println("教授投篮及攻防战术");
}
}

//主方法
class  InterfaceDemo2
{
public static void main(String[] args)
{
PingPangPlayer ppp = new PingPangPlayer("张继科",28);/*PingPangPlayer("张继科"，28);//错误：中文逗号*/
System.out.println("这个运动员叫：" + ppp.getName() + "年龄：" + ppp.getAge());
ppp.eat();
ppp.sleep();
ppp.speak();
ppp.study();
System.out.println("---------------------");
PingPangCoath ppc = new PingPangCoath("刘国梁",40);
System.out.println("这个教练员叫：" + ppc.getName() + "年龄：" + ppc.getAge());
ppc.eat();
ppc.sleep();
ppc.speak();
ppc.teach();
System.out.println("---------------------");
BasketBallCoath bbc = new BasketBallCoath("宫鲁鸣",50);
System.out.println("这个教练员叫：" + bbc.getName() + "年龄：" + bbc.getAge());
bbc.eat();
bbc.sleep();
bbc.teach();
System.out.println("---------------------");
BasketBallPlayer bbp = new BasketBallPlayer("王治郅",38);
System.out.println("这个运动员叫：" + bbp.getName() + "年龄：" + bbp.getAge());
bbp.eat();
bbp.sleep();
bbp.study();
System.out.println("---------------------");
SpeakEnglish p = new PingPangPlayer();
p.speak();

}
}