Java进阶篇之抽象

水深无声 2024-05-05 06:41 9阅读 0赞

## Java编程之面向抽象 ##

#### 本篇内容： ####

#### 1.抽象的引入 ####

#### 2.抽象在Java中的作用 ####

#### 3.应用场景 ####

#### 4.小结 ####

### 1.抽象的引入 ###

抽象即没有任何具体的实际内容，一般是共有的属性或行为。比如：**描述一个人（对象），每个人都有自己的出行方式，不同的交通工具出行的方式不一样，比如单车，那么出行的方式就是踩踏板；比如出行方式是摩托车，那么出行的方式就是踩一脚油门；比如小汽车，那么就是挂档松离合，踩油门等……**  
**根据上面的描述，我们用Java代码来实现一下：**

*  **使用所熟悉的面向对象的知识来实现：**

public class Human{
         //定义人类为父类
        public void run(){
         //跑的方法
            System.out.println("请子类自行实现");
        }
    }
    
    public class Teacher extends Human{
         //教师类继承人类 重写跑方法
    	@Override
        public void run(){
        
            System.out.println("11路开到底");
        }
    }

public class Test{
         //测试类
    	public static void main(String[] args){
         //主方法
    		//实例化
    		Teacher teacher = new Teacher();
    		Human human = new Human();
    		//调用方法
    		teacher.run(); // 正常
    		human.run(); // 非正常，应该由子类调用
    	}
    }

*  **看上述代码可知道，父类里面的跑方法没有任何要实现的功能，这个方法(行为)是为了让其子类来实现具体的行为的，但是看测试类调用的了父类的方法，那么这就形成了可以创建任意 Human 对象，调用其方法。而我们想要实现的现象是：  
    父类里面只提供有这个方法或者说功能，但是具体怎么做，就是要看其子类如何去操作，也就是说具体的功能如何实现应由子类来自己完成。由此面向对象的知识已经很难实现这个问题了，那么今天就来解决一下这个问题吧。**

### 2.抽象在Java中的作用 ###

**在 Java 中抽象的关键字是 abstract,放在class关键字的后面。被修饰的类叫抽象类，被修饰的方法叫抽象方法。注意：属性是不能用abstract修饰的！！** 抽象类里面有抽象的也可以有非抽象的，比如方法，可以有抽象方法，也可以有具体方法的实现。那么接下来我们可以用abstract 抽象方法来实现上述的需求。示例代码：

// 抽象类
    public abstract class Human{
        
        // 抽象方法
        public abstract void run();
    }

public class Teacher extends Human{
         //教师类继承抽象类 重写run方法
    	@Override
        public void run(){
        
            System.out.println("11路开到底");
        }
    }

public class Test{
         //测试类
    	public static void main(String[] args){
         //主方法
    		//实例化
    		Teacher teacher = new Teacher();
    		//Human human = new Human(); //无法通过编译
    		//调用方法
    		teacher.run(); //运行结果:11路开到底
    	}
    }

*  **以上就是使用了抽象编程的用法。用了抽象的方法，那么就很容易实现了一开始的需求。那么我们来分析一下何为抽象方法，抽象方法就是如上述那*没有具体内容，也不需要大括号：***

public abstract void 方法名();

*  注意，抽象方法不能是 **private** 私有方法。  
    在上面的例子中是否发现抽象类无法实例化，为何呢？接下来就是抽象类了，一开始已经说明了用关键字**abstract**修饰的类就是抽象类，那么如何编写呢，请看下面代码：

//创建了抽象类A 里面无任何东西
    public abstract class A{
        }
    
    //创建了抽象类B
    public abstract class B{
        
    	//抽象方法f
        public abstract void f();
    }

*  **上述就是抽象类的定义，接下来我们来再次实例化看看能不能行：**

A a = new A(); // 编译失败
    B b = new B(); // 编译失败

*  **由此可见，抽象类是无法实例化的，这里报了个这样的错误：Cannot instantiate the type A/B，意思很明显，就是该类型不能实例化。那么为何呢？其实这个思考一番也不难得出结论，是否还记得类与对象的关系？对象是从类而来的，对象的类型就是类。那么现在类是抽象化的，那么也就是说对象是抽象的，无实际的实体，那么如何实例化呢？**

### 3.应用场景 ###

**使用 abstract 抽象的场景：  
（1）对方法进行抽象：当某个方法无法描述或是不方便描述的时候，可以不定义具体的实现并要求由子类去定义，使用 abstract 抽象修饰为未实现方法  
（2）当类不能直接被实例化，或者类不是完整的，应该由子类去扩展并具体实现，那么可以将类修饰为 abstract class 抽象类  
（3）子类继承抽象类以后，子类也会间接获得抽象类中的抽象方法，如果子类不实现抽象方法那么依然必须保持为抽象类，也可以将抽象方法重写从而变为具体类  
（4）将多个子类抽象为一个父类，使用抽象类来实现多态，即抽象类为父类引用  
举例，形状都有计算周长和面积的方法，但是没有统一的公式，各种形状计算方式各不相同，那么我们可以使用抽象来定义形状类，而这些方法交给具体的子类去实现。**  
示例代码：

public abstract class Shape{
         //定义形状抽象类
    	//计算周长抽象方法
        public abstract double calculatePerimeter();
        //计算面积抽象方法
        public abstract double calculateArea();
    }

// 子类实现抽象方法
    class Circle extends Shape{
        
        @Override public double calculatePerimeter() {
        
        	final double PI = 3.14;
        	double d = 20;
            return PI*d;
        }
        @Override public double calculateArea() {
        
        	final double PI =10;
        	double r = 20;
            return (r*r*PI);
        }
    }

// 子类实现抽象方法
    class Rectangle extends Shape{
        
        @Override public double calculatePerimeter() {
        
            return 1;
        }
        @Override public double calculateArea() {
        
            return 2;
        }
    }

public class Test{
         //测试类
    	public static void main(String[] args){
         //主方法
    		//实例化
    		Circle circle = new Circle();
    		Shape rectangle = new Rectangle();
    		//调用方法
    		circle.calculatePerimeter();
    		rectangle.calculateArea();
    	}
    }

*  上述就是一些应用场景的使用，看Rectangle实例化的类型是抽象类，这样是不会报错的，这实现了应用场景的第4点。
 *  **使用 abstract 抽象需要注意的地方：  
    （1）拥有抽象方法的类必须声明为抽象类，抽象方法不能用 private 修饰  
    （2）抽象类可以没有抽象方法，子类父类均可以定义为抽象类  
    （3）抽象类不能直接实例化**

### 4.小结 ###

以上就是我所理解的Java面向抽象化的编程，面向抽象编程还有一个接口，接口是比抽象类还抽象的一个东西，学习好抽象，再学习接口，会有另一番思考。