Java中抽象类与抽象方法：父类提供定义，子类具体实现

摘要和抽象类简介

父类中的方法由其子类重写，子类的实现是不同的。然后，父权制方法声明和方法主题仅是有意义的，该方法的主体没有存在的含义（因为子类对象将调用重写本身的方法）。换句话说，父类可能知道哪些功能应该具有哪些功能，但是如何实现父类还不清楚（由子类本身确定）。将其交给Zixu自己实施。我们称之为无用的方法抽象方法。 Java语法规定了抽象方法类别是抽象类。

抽象使用格式

摘要是摘要，用于修改方法和类。修改方法是抽象方法，修改类是抽象类。

抽象方法和抽象类

使用“摘要”关键字修改方法，此方法成为一种抽象方法。抽象方法仅包含一个方法名称，但没有方法。

修饰符 abstract 返回值类型 方法名 (参数列表)；
public abstract void run()；

如果类包含抽象方法，则该类必须是抽象类。注意：抽象类不一定具有抽象方法，但是具有抽象方法的类必须定义为抽象类。

abstract class 类名字 { 
  
}
public abstract class Animal {
    public abstract void run()；
}

抽象使用

要求：抽象子类的继承必须重写父类的所有抽象方法。否则，子类也必须称为抽象类。

// 父类,抽象类
abstract class Employee {
	private String id;
	private String name;
	private double salary;
	
	public Employee() {
	}
	
	public Employee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	// 抽象方法
	// 抽象方法必须要放在抽象类中
	abstract public void work();
}
// 定义一个子类继承抽象类
class Manager extends Employee {
	public Manager() {
	}
	public Manager(String id, String name, double salary) {
		super(id, name, salary);
	}
	// 2.重写父类的抽象方法
	@Override
	public void work() {
		System.out.println("管理其他人");
	}
}
// 定义一个子类继承抽象类
class Cook extends Employee {
	public Cook() {
	}
	public Cook(String id, String name, double salary) {
		super(id, name, salary);
	}
	@Override
	public void work() {
		System.out.println("厨师炒菜多加点盐...");
	}
}
// 测试类
public class Demo10 {
	public static void main(String[] args) {
		// 创建抽象类,抽象类不能创建对象
		// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
//		Employee e = new Employee();
//		e.work();
		
		// 3.创建子类
		Manager m = new Manager();
		m.work();
		
		Cook c = new Cook("ap002", "库克", 1);
		c.work();
	}
}

抽象类的特征

可以说抽象类的特征是丢失和丢失

目的：抽象类具有具有抽象方法的能力。

丢失：抽象类失去了创建对象的能力。

其他成员（建设性方法，实例方法，静态方法等）都可以使用抽象类。

抽象细节

1。抽象类无法创建对象。如果创建它们，则无法通过错误。它只能创建其非抽吸分类的对象。

2。在抽象类中，可以有一种建设性方法。当它是子类的目标时，最初使用父类成员。

3。在抽象类中，没有抽象方法，但是带有抽象方法的类必须是抽象类别。

4。抽象子类必须在抽象父类中重写所有抽象方法，否则子类也必须定义为抽象类，并且不能传递汇编并报告错误。

5。抽象类的含义应由子类继承。

抽象类别的含义存在

抽象类的含义应由子类继承，否则抽象类将毫无意义。抽象类可以迫使子类，并且必须根据规定的格式重写。

概述

该界面是一个更彻底的抽象。在包括JDK7在内的JDK7之前，接口都是抽象方法。接口也无法创建对象。

格式如下：

//接口的定义格式：
interface 接口名称{
    // 抽象方法
}
// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

抽象方法

接口成分的功能：接口仅包含界面中的抽象方法和常数

接口成分：

注意：接口中的抽象方法将自动添加公共抽象修改程序员以自动添加它！路口

根据规格：建议界面中的摘要方法不编写公共摘要。因为没有必要，因此默认情况下会添加。

持续的：

接口中定义的成员变量将添加：公共静态最终修改。换句话说，接口中定义的成员变量实际上是一个常数。这是使用公共静态最终修改，不能修改变量值，并且可以使用接口名称直接访问静态变量，因此也称为常数。必须给出常数的初始值。持续的命名规格推荐的字母全部大写，并且多个单词通过底线连接。

案例示范

public interface InterF {
    // 抽象方法！
    //    public abstract void run();
    void run();
    //    public abstract String getName();
    String getName();
    //    public abstract int add(int a , int b);
    int add(int a , int b);
    // 它的最终写法是：
    // public static final int AGE = 12 ;
    int AGE  = 12; //常量
    String SCHOOL_NAME = "黑马程序员";
}

基本实现

类和界面之间的关系是实现这种关系，即类实现界面。该类可以称为接口的实现类或接口的子类。实现的实现类似于继承，格式相似，但是关键字不同，并且``insterments''的关键字。

/**接口的实现：
    在Java中接口是被实现的，实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{
}

从上述格式可以看出，可以实现界面。

集体实施接口要求和意义

1。所有抽象方法必须重写所有实现的接口。

2。如果一个类实现接口，但是没有重写接口的整个部分的抽象方法，则此类也必须定义为抽象类。

3。意义：界面反映了规范。接口是实现类的强制性约束。要么完成接口语句的功能，要么也将其定义为抽象类。这是强制性的规范。

/**
   接口：接口体现的是规范。
 * */
public interface SportMan {
    void run(); // 抽象方法，跑步。
    void law(); // 抽象方法，遵守法律。
    String compittion(String project);  // 抽象方法，比赛。
}
public class PingPongMan  implements SportMan {
    @Override
    public void run() {
        System.out.println("乒乓球运动员稍微跑一下！！");
    }
    @Override
    public void law() {
        System.out.println("乒乓球运动员守法！");
    }
    @Override
    public String compittion(String project) {
        return "参加"+project+"得金牌！";
    }
}
public class TestMain {
    public static void main(String[] args) {
        // 创建实现类对象。
        PingPongMan zjk = new PingPongMan();
        zjk.run();
        zjk.law();
        System.out.println(zjk.compittion("全球乒乓球比赛"));
    }
}

班级和接口的多个实施案例

类和接口之间的关系更加实现，一个类可以同时获得多个接口。

//首先我们先定义两个接口，代码如下：
public interface Law {
    void rule();
}
public interface SportMan {
    void run();
}
public class JumpMan implements Law ,SportMan {
    @Override
    public void rule() {
        System.out.println("尊长守法");
    }
    @Override
    public void run() {
        System.out.println("训练跑步！");
    }
}

界面和接口的更多继承

在Java中，接口和接口之间可能有更多的继承：也就是说，一个接口可以同时继承多个接口。每个人都必须注意：

类和界面是真实的关系

界面和接口是继承关系

接口继承接口是将其他接口的抽象方法与此接口合并。

public interface Abc {
    void go();
    void test();
}
/** 法律规范：接口*/
public interface Law {
    void rule();
    void test();
}
 *
 *  总结：
 *     接口与类之间是多实现的。
 *     接口与接口之间是多继承的。
 * */
public interface SportMan extends Law , Abc {
    void run();
}

界面的详细信息

1。当两个接口中有相同的抽象方法时该怎么办？

>只需写一次即可。此时重写的方法不仅显示重写1个接口，还显示重写2个接口。

2。当实现类可以继承A类时，同时其他接口又如何呢？

>继承的父亲班就像爸爸

>实施界面就像是教父

>它可以继承类，然后实现多个接口，但是必须实现接口中的所有抽象方法。

3。类可以同时实现其他接口，可以继承抽象类吗？

>实现类可以继承一个抽象类，然后实现多个接口，但是其中所有抽象方法必须重写。

4。实现Zi，实现接口并继承FU类。假设接口中有一种方法，则父类中有相同的方法。如何操作子类？

>处理方法1：如果父类中的方法可以满足当前的业务需求，则无需在子类别中重写。

>处理方法2：如果父类中的方法无法满足当前业务的需求，则需要将其重写在子类中。

5。如果接口中有10种抽象方法，但是在实现类中，我只需要使用其中一种即可。我应该怎么办？

>在接口和实现类的中间，创建一个新的中级类（适配器类）

>让该适配器类实现以实现接口，并尽快重写接口中的所有方法。

>让子类继承此适配器类，哪种方法可以重写。

>由于中级阶层没有任何实际意义，因此通常将其定义为中产阶级的抽象，因此不允许外界从外界创建对象

内部类别概述

在另一类B中定义一个A类A类。a内部称为内部类，B称为外部类。内部阶级可以理解为寄生，外部阶级可以理解为宿主。

您什么时候使用内部课程？

一件事情里面有一个独立的事情。内部事物不能独立使用外部

内部班级的分类

1。内部类，类是在成员位置定义的（该方法称为类的成员位置，并且没有通过静态修改的内部类）

2。静态内部类，类是在成员位置定义的（该方法称为类的成员位置，并且有一个静态修改的内部类）

3。当地内部类，方法中的类定义

4。匿名内部类，没有名称的内部类，可以在方法中或外部方法之外。

匿名内部类[关键点]概述

匿名内部类：这是内部类的简化写作。他是一个内部班级，暗示他的名字。在开发中，最常用的内部类是匿名内部类。

new 类名或者接口名() {
     重写方法;
};

包括：

继承或实施

方法重写

创意对象

因此，就语法而言，这实际上是一个匿名的内部类对象

我什么时候使用匿名内部课程？

实际上，如果我们要定义仅使用一次的类，则可以考虑使用匿名内部类。匿名内部类的基本效果是简化代码。

当我们以前使用界面时，我们似乎会执行以下步骤：

1。定义子类

2。在接口中重写该方法

3。创建一个子类对象

4。调用重写方法

interface Swim {
    public abstract void swimming();
}
// 1. 定义接口的实现类
class Student implements Swim {
    // 2. 重写抽象方法
    @Override
    public void swimming() {
        System.out.println("狗刨式...");
    }
}
public class Test {
    public static void main(String[] args) {
        // 3. 创建实现类对象
        Student s = new Student();
        // 4. 调用方法
        s.swimming();
    }
}

匿名内部类和格式

先决条件：匿名内部类必须继承父类或实现父界面。

格式：

new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {
        // 执行语句
    }
};

如何使用

interface Swim {
    public abstract void swimming();
}
public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
		new Swim() {
			@Override
			public void swimming() {
				System.out.println("自由泳...");
			}
		}.swimming();
        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };
        s2.swimming();
        s2.swimming();
    }
}

结果如下：

匿名内部类的功能

1。定义一个没有名称的内部类

2。此类实现父类或父界面

3。匿名内部类将创建这个没有名称的课程

使用匿名内部类的方案

当该方法的形式参数是接口或抽象类时，匿名内部类也可以作为参数传递。

interface Swim {
    public abstract void swimming();
}
public class Demo07 {
    public static void main(String[] args) {
        // 普通方式传入对象
        // 创建实现类对象
        Student s = new Student();
        
        goSwimming(s);
        // 匿名内部类使用场景:作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);
        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }
    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}