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

男娘i 2024-02-17 19:06 8阅读 0赞

一 抽象类：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");
    	}
    	
    }

结果。  
![Center][]

接口的成员特点：

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

结果：

![Center 1][]

最后：

抽象类和接口的区别是什么?  
  
  
1. 成员不一样  
  
  
抽象类：可以有构造方法；可以有成员变量和量；可以有抽象和非抽象方法  
  
  
接口：没有构造函数；成员变量只能是静态常量；只有公共抽象方法  
  
  
2. 关系不一样  
  
  
抽象类与类之间的关系是继承关系  
  
  
接口与类之间的关系是实现关系  
  
  
3设计理念不一样  
  
  
抽象类是对于事物本质的抽象  
  
  
接口是对拓展功能的抽象

#### 最后附上JDK使用文档API [下载][Link 1] ####

[Center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/c07ea794bb6d484ebf59d4a51238f3ca.png
[Center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/edd0374a691042ee9a89904264ad9486.png
[Link 1]: http://download.csdn.net/detail/onceing/9748619