黑马程序员----------java高新技术之抽象类和接口

----------------------android培训、java培训、期待与您交流！
----------------------

面向对象三大特性已经总结了，下面简单总结一下java中的抽象类和接口。

抽象类：(abstract)

(1)只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。

(2)抽象类的特点

A：一个类如果有了抽象方法，那么这个类必须是抽象类。(抽象类里边可以没有抽象方法)。

B：抽象类是不能够被实例化的。不能够创建对象的。

C：如果一个类继承抽象类，那么，它要么实现抽象类中的所有抽象方法，

要么本身也是抽象类。

(3)抽象类的成员特点：

A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)

B：成员方法：抽象类中分为两种方法，一种是抽象方法，这种方法在子类中必须要被实现。

一种是普通的方法。可以被子类直接继承使用。

C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。

它的构造方法有用吗？有，为了让子类实例化的时候使用。

(4)举例：教师举例，学生举例，员工举例

(5)抽象类的相关问题：

A：抽象类中是否有构造函数？参照(3)里面的C。

B：抽象关键字abstract不可以和哪些关键字共存？

**private

***私有的，外部直接无法访问。

**static

***那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。

**final

***final修饰的方法不能被重写。所以它和abstract冲突。

C：抽象类中可不可以没有抽象方法？

**可以。防止其他类创建该类对象。

简单写一个抽象类：

abstract class Role{
private String name;
//构造方法
public Role(){}

public Role(String name) {
this.name = name;
}

// set/get方法
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

//业务方法
abstract public int attack();
}

class Magicer extends Role{
private int level = 1;

public Magicer(){}

public Magicer(String name, int level) {
super(name);
if (level > 10 || level < 1){
System.out.println("level error!");
return;
}
this.level = level;
}

public int getLevel() {
return level;
}

public void setLevel(int level) {
if (level<1 || level > 10){
System.out.println("level error!");
return;
}
this.level = level;
}

public int attack(){
return level * 5;
}
}

class Soldier extends Role{
private int hurt;

public Soldier(){}

public Soldier(String name, int hurt) {
super(name);
this.hurt = hurt;
}

public int getHurt() {
return hurt;
}

public void setHurt(int hurt) {
this.hurt = hurt;
}

public int attack(){
return hurt;
}
}

class Team{
private Role[] teams = new Role[6];
private int index = 0;
public Team(){}
public void addMember(Role role){
if (index == 6){
System.out.println("组队已满！");
return;
}
teams[index] = role;
index++;
}
public int attackSum(){
int sum = 0;
for(int i = 0; i<index; i++){
sum += teams[i].attack();
}
return sum;
}
}

public class TestRole {
public static void main(String[] args) {
Magicer m1 = new Magicer("tom", 5);
Magicer m2 = new Magicer("jerry", 10);
Soldier s1 = new Soldier("john", 20);
Soldier s2 = new Soldier("jim", 40);
Team team = new Team();
team.addMember(m1);
team.addMember(m2);
team.addMember(s1);
team.addMember(s2);
int totalAttack = team.attackSum();
System.out.println("总攻击伤害为" + totalAttack);
}
}

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。铁（iron）门、玻璃门这两个类的抽象类是门，说明他们都是门。

接口

接口(interface)

(1)接口的由来：当一个类中的方法都是抽象的时候，你没必要定义为抽象类，

定义为接口就可以了。

(2)解决了java中只能单继承的问题。(对多继承进行了优化)

A：类与类：只能是单继承。

B：接口与接口：可以是单继承，也可以是多继承。

C：类与接口：可以是单实现，也可以是多实现。

(3)成员特点：

A：只有成员变量和成员方法。

B：成员变量 默认修饰符 public static final

**int x = 20;

**其实是这样的 public static final int x = 20;

C：成员方法 默认修饰符 public abstract

**void show();

**其实是这样的 public abstract void show();

建议：自己手动加上修饰符。

(4)接口特点：

A：接口是对外暴露的规则

B：接口是功能的扩展

C：接口降低了程序的耦合性。

**内聚(自己实现功能的能力)

**高内聚，低耦合。

举例：主板和CPU,USB接口,电源插座。

D：扩展说了下接口的理解

**狭义的理解就是java中的接口。

**广义的理解就是：任何定义的规范都是接口。

接口可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

既然说接口是一种特殊的抽象类，那么两者有什么区别吗？

接口和抽象类的区别：

A：抽象类只能被单继承；接口可以被多实现。

B：抽象类中的成员：成员变量:可以是常量，也可以是变量。

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

构造方法:虽然不可以创建对象，但是可以给子类实例化用。

接口中的成员：成员变量：只能是常量。默认修饰符 public static final

成员方法：只能是抽象的。默认修饰符 public abstract

C：抽象类中定义的是体系结构中的共性的内容。

接口中定义的是对象的扩展功能。

D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

接口被实现表示的是: "like a"的关系。xx像yy中的一种。

(6)学生：Student

A：属性：学号,姓名,年龄

B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)

发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。

这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，

我们定义一个接口来放抽烟这个功能。

interface Smoking

{

public abstract void smoking();

}

描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

SmokeStudent ss = new SmokeStudent();

ss.eat();

ss.study();

ss.smoking();

老师：Teacher

A：属性 教师编号,姓名,年龄

B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)

发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。

这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，

我们定义一个接口来放抽烟这个功能。

interface Smoking

{

public abstract void smoking();

}

描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking

SmokeTeacher st = new SmokeTeacher();

st.eat();

st.teach();

st.smoking();

最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。

所以，我们进一步向上抽取。来了一个Person类

Person：属性：姓名，年龄

行为：吃饭(抽象eat)

下面比较一下两者的语法区别：

1. 抽象类可以有构造方法，接口中不能有构造方法。

2. 抽象类中可以有普通成员变量，接口中没有普通成员变量

3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

接口可以实现也可以继承，抽象类不行

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的

所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

package cn.itheima;

class Person {
//年龄
public static int age = 0;

//出生
Person(){}

//克隆人
Person(int age){
this.age = age;
}

//过了一年
public void grow(){
age++;
}
}

public class staticDemo {

Person p = new Person(10);

static Person p1,p2;

static{
System.out.println("p1.age =" + p1.age + ",p2.age =" + p2.age);
p1 = new Person(20);
System.out.println("p1.age =" + p1.age + ",p2.age =" + p2.age);
p2 = new Person(30);
System.out.println("p1.age =" + p1.age + ",p2.age =" + p2.age);
}

public static void main(String[] args) {

staticDemo sd = new staticDemo();

System.out.println("p.age =" + sd.p.age);
System.out.println("p1.age =" +p1.age + ",p2.age =" + p2.age);
p1.grow();
System.out.println("p1.age =" +p1.age + ",p2.age =" + p2.age);
System.out.println(sd.p.age);
}
}

代码2：
public class StaticCls {
public static void main(String[] args) {
OuterCls.InnerCls oi = new OuterCls.InnerCls();
}
}

class OuterCls {
public static class InnerCls {
InnerCls() {
System.out.println("InnerCls");
}
}
}

----------------------android培训、java培训、期待与您交流！
----------------------