JAVA 抽象类&接口（一）

Myth丶恋晨 2023-05-31 03:23 28阅读 0赞

### 文章目录 ###

*  1.抽象与接口
 *   *  2回顾一下面向对象
 *  3.抽象类
 *   *  3.1 特征
 *  4. 接口
 *   *  4.1 接口的特点
     *  4.2 代码

# 1.抽象与接口 #

## 2回顾一下面向对象 ##

*  抽象，将现实中的事物抽取出事物的属性和方法，封装成对象，通过对象的实例化和调用，完成需求。  
    **Student stu = new Student();**
 *  封装，隐藏类的内部细节，提供外部访问的接口。  
    将多次重复运行的代码，封装到方法中，较少代码代码的冗余，提高代码的重用性。  
    **private int a = 10;  
    public int getA()\{\}  
    public void setA(int a)\{\}**
 *  继承，子类继承父类中的共有属性和方法。关键字是extends。  
    充分体现了java对象重用的特性，继承属性，重写方法。提高了代码的重用性。  
    **class a extends b**
 *  多态，一种类型，多种形态。父类对象在编译器是父类形态，运行期是子类形态。  
    提高了java系统的可插拔性。  
    **Pet pet;// 父类类型。  
    pet = new Penguin(“qq”,2,85,50,“雌”);  
    pet = new Dog(“大黄”,3,75,85,“黄色”);**

# 3.抽象类 #

*  1 .**什么是抽象类？**  
    abstract 修饰的类叫做抽象类。
 *  2.**什么是抽象方法？**  
    使用abstract修饰的方法叫做抽象方法，抽象方法不能有具体的实现，子类必须重写。

## 3.1 特征 ##

1.  abstract 修饰的类是抽象类：

*  1： 抽象类不能实例化。
 *  2: 抽象类中有抽象方法，子类必须重写。
 *  3: 抽象类中可以有非抽象方法，不要求子类强制实现。
 *  4：如果一个类中，有抽象方法，那么这个类一定是抽象类。
 *  5： 如果一个类是抽象类，这个类中一定有抽象方法吗？不一定。

下面展示一些 `宠物父类 抽象类代码片`。

public abstract class Pet {
    
    	private String name;
    	private int age;
    	private int health;
    	private int love;
    
    
    public String getName() {
    	return name;
    }
    public void setName(String name) {
    	this.name = name;
    }
    public int getAge() {
    	return age;
    }
    public void setAge(int age) {
    	this.age = age;
    }
    public int getHealth() {
    	return health;
    }
    public void setHealth(int health) {
    	this.health = health;
    }
    public int getLove() {
    	return love;
    }
    public void setLove(int love) {
    	this.love = love;
    }
    public Pet() {
    	super();
    }
    public Pet(String name, int age,  int health, int love) {
    	super();
    	this.name = name;
    	this.age = age;
    	this.health = health;
    	this.love = love;
    }
    
    // 抽象类中有抽象方法。
    public abstract void eat();
    
    // 非抽象方法。
    public void show(){
    	
    };

# 4. 接口 #

**什么是接口？**  
接口不是类，interface修饰 一种数据类型。

*  1.Java为什么需要接口
 *  通过接口实现多继承
 *  用于实现耦合
 *  如下图所示，一个类扩展了另一个类，一个接口扩展了另一个接口，一个类实现了一个接口。

链接: [link][].  
![接口][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70]

## 4.1 接口的特点 ##

1.  就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。

如果一个类实现了一个接口中要求的所有的方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。（必须记住：**抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类**）。

——————————————————————

1.  接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

*  除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
 *  接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

--------------------

## 4.2 代码 ##

下面展示一些 `普通类代码片`。

public class ABDemo implements AInterface,BInterface{
    
    @Override
    public void b() {
    	// TODO Auto-generated method stub
    	
    }
    
    @Override
    public void a() {
    	// TODO Auto-generated method stub
    	
    	}
    
    }

下面展示一些 `A接口代码片`。

public interface AInterface {
    
    // 方法。
    public void a();
    
    }

下面展示一些 `B接口代码片`。

public interface BInterface {
    
    // 方法。
    public void b();
    
    }

下面展示一些 `final 代码片`。l

**注意：！！！！**

*  final : 最终的。不可改变的。
 *  final 修饰变量。表示常量，值不能再次赋值。常量要求全部大写。
 *  final 修饰方法。表示方法不能被重写。
 *  final 修饰类。表示类不能被继承。
 *  final 修饰对象，当前对象不能再new实例。
 *  String 就是被final修饰的类，不能被继承。
    
        public class FinalTest {
        
         public static void main(String[] args) {
         // 声明变量
         int a = 10;// a 表示变量。
         String b = "hello";
         
         // 常量
         final int AGEAVGSUM = 30;
         //		C = 35;// 使用final修饰的变量为常量，不能修改。
         
         
         
         // final修饰对象会怎么样。
         final Demo demo = new Demo();
         //		  demo = new Demo();// 错误，被final修饰的对象不能再new实例。
         demo.a = 30;
         System.out.println(demo.a);
         }
        
         }
         // 普通类 父类。
          class Demo{// final修饰的类不可以有子类。
        
          int a = 20;// 注意这个变量。
        
         public final void show(){// 这个方法不能被重写。
         
         }
         
         }
         // 子类
         class DemoChild extends Demo{
         //	@Override
         //	public void show() {// 错误，此方法在父类中被final修饰，表示不能被重写。
         //		// TODO Auto-generated method stub
         //		super.show();
         //	}
        
         }
 *  **其中注意的·！！！**
 *

**子类**  
class DemoChild extends Demo\{  
// @Override  
// public void show() \{// 错误，此方法在父类中被final修饰，表示不能被重写。  
// // TODO Auto-generated method stub  
// super.show();

——————————————————  
***JAVA 抽象类，接口第一篇概括如上，希望有能get到的点！！！***

[link]: https://mp.csdn.net
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70]: /images/20230531/78bcc4ed59bd455e9d3582116b5c04d8.png