java基础学习面向对象之抽象类和接口 五-11

一 抽象类：abstract。
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。，分析事物不确定时，就抽象

特点

1.抽象方法只能定义在抽象类中。

2.抽象方法和抽象类必须被abstract修饰

3.抽象类不可以用new 创建对象，因为创建对象没有意义

4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。

抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。

抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。

抽象类可以包含 普通方法 成员变量 构造方法

例子：

abstract class enmployee{

private String name;
private int id;
private double money;

public enmployee(String name, int id, double money) {
super();
this.name = name;
this.id = id;
this.money = money;
}

public abstract void work();
}

class yuangong extends enmployee{

public yuangong(String name, int id, double money) {
super(name, id, money);

}

public void work(){
//员工工作
}

}

class jingli extends enmployee{

double jiangjin;
public jingli(String name, int id, double money,double jiangjin) {
super(name, id, money);
this.jiangjin=jiangjin;

}

public void work(){
//经理工作
}

}

模板方法模式：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分

在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。将确定的部分final修饰 ，禁止修改。

/*
* 获取一段程序的运行时间
*
*/

abstract class GetTime
{
public final void gettime()
{
long start = System.currentTimeMillis();

runcode();

long end = System.currentTimeMillis();
System.out.println(end-start);

}

public abstract void runcode();
}

class Subtime extends GetTime{
public void runcode(){
for(int x=0;x<1000;x++){
System.out.println(x);
}
}
}

二、接口 interface

1.    什么是接口?

java为了弥补单继承的缺陷,定义了一功能接口,可以多实现.接口是java中一系列方法的声明，是一些方法特征的集合， 其里面所有的方法都是抽象方法,所以也可以称其为一个特殊的抽象类,里面的成员有固定的修饰符,不写也会自动加.

成员变量前默认加:publicstatic final

成员方法前默认加public abstract

2.    接口有什么作用?

 

接口就是用来实现的,接口一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。那么接口就类似于制定了规则,外部实现其的类必须重写其所有方法.

接口可以多实现,那么就大大增强扩展性.

通过接口实现两个功能的对接,会大大降低二者耦合性.有利于程序的维护.

3.    接口怎么用?

格式:

interface 接口名

{

[public staticfinal] 属性

[publicabstract] 方法

}

interface 接口名 extends 接口1,接口2.......-------接口的继承,支持多继承

{

不用重写方法

}

class 类名 implements 接口1,接口2......-----类对接口的多实现

{

重写所有方法;

}

abstract class 类名 implements 接口1,接口2,......

{

方法可以重写也可以不重写

}

 

 

4.    接口什么时候用?

当一个类只有方法的特征,而方法的实现各不相同,同是这个功能又有较强的括展性

这个时候就可以定义一个接口,

 

5.    接口有什么特点?

接口没有构造函数

接口的属性都是常量

接口可以多实现，因为接口中的方法全是抽象方法，没有具体方法实现，我们如果发现不同接口中出现相同的方法，那么只需要实现一次.

接口与接口可以多继承

抽象类与接口的区别

1.类是单继承，接口可多实现

2.继承 is a    实现 like a

3.抽象类中可以有实体方法，接口中全是抽象方法

接口基本实现;

package demo;
/**
*
* @author Angus
* 接口的特点
* 1：接口不能被实例化
* 2：接口中的方法必须被子类实现，或者子类为抽象类
*/
public class InterfaceDemo {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();

Animal a = new Dog();
a.eat();
}

}
interface Animal{
public abstract void eat();
}
class Dog implements Animal{

@Override
public void eat() {
System.out.println("eat dog");
}

}

结果。



接口的成员特点：

package demo;
/**
*
* @author Angus
* 接口的成员特点
*   成员变量：接口中只有常量
*   		有默认修饰符  public static final
*   		推荐：自己给出修饰符
*   构造方法：
*   		没有构造方法
*   成员方法：接口中的方法都是抽象的。
*   		有默认修饰符  public abstract
*   		推荐：自己给出修饰符
*/
public class InterfaceDemo {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.show();

Animal a = new Dog();
a.eat();

}

}
interface Animal{
int num = 100;
public  int x= 10;
public final int y = 20;
public abstract void eat();
}
class Dog implements Animal{

@Override
public void eat() {
System.out.println("eat dog");
}
public void show(){
System.out.println(x);
System.out.println(y);
System.out.println(Animal.x);
System.out.println(Animal.y);
}
}

结果：



最后：

抽象类和接口的区别是什么?

1. 成员不一样

抽象类：可以有构造方法；可以有成员变量和量；可以有抽象和非抽象方法

接口：没有构造函数；成员变量只能是静态常量；只有公共抽象方法

2. 关系不一样

抽象类与类之间的关系是继承关系

接口与类之间的关系是实现关系

3设计理念不一样

抽象类是对于事物本质的抽象

接口是对拓展功能的抽象

 

最后附上JDK使用文档API 下载