Java 抽象类使⽤⽅法【⾮常详细】
⼀、抽象类的基本概念
普通类是⼀个完善的功能类，可以直接产⽣实例化对象，并且在普通类中可以包含有构造⽅法、普通⽅法、static⽅法、常量和变量等内容。
⽽抽象类是指在普通类的结构⾥⾯增加抽象⽅法的组成部分。
那么什么叫抽象⽅法呢？在所有的普通⽅法上⾯都会有⼀个“{}”，这个表⽰⽅法体，有⽅法体的⽅法⼀定可以被对象直接使⽤。⽽抽象⽅法，是指没有⽅法体的⽅法，同时抽象⽅法还必须使⽤关键字abstract做修饰。
⽽拥有抽象⽅法的类就是抽象类，抽象类要使⽤abstract关键字声明。
范例：定义⼀个抽象类
抽象类的特点：
1，抽象⽅法⼀定在抽象类中。
2，抽象⽅法和抽象类都必须被abstract关键字修饰。
3，抽象类不可以⽤new创建和实例化对象。因为抽象类本⾝就是不完整的。
4，抽象类中的抽象⽅法要被使⽤，必须由⼦类复写所有的抽象⽅法后，建⽴⼦类对象调⽤。
如果⼦类只覆盖了部分抽象⽅法，那么该⼦类还是⼀个抽象类。
⼆、抽象类的使⽤抽象类的注意事项：
abstract  class A{//定义⼀个抽象类
public  void  fun(){//普通⽅法
System.out .println("存在⽅法体的⽅法");
}
public  abstract  void  print();//抽象⽅法，没有⽅法体，有abstract 关键字做修饰
}
抽象⽅法的注意事项：
范例：直接实例化抽象类的对象
package com.wz.abstractdemo;
abstract class A{//定义⼀个抽象类
public void fun(){//普通⽅法
System.out.println("存在⽅法体的⽅法");
}
public abstract void print();//抽象⽅法，没有⽅法体，有abstract关键字做修饰
}
public class TestDemo {
public static void main(String[] args) {
A a = new A();
}
}
运⾏：
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Cannot instantiate the type A
at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)
从上可知，A是抽象的，⽆法直接进⾏实例化操作。为什么不能直接实例化呢？当⼀个类实例化之后，就意味着这个对象可以调⽤类中的属性或者放过了，但在抽象类⾥存在抽象⽅法，⽽抽象⽅法没有⽅法体，没有⽅法体就⽆法进⾏调⽤。既然⽆法进⾏⽅法调⽤的话，⼜怎么去产⽣实例化对象呢。
抽象类的使⽤原则如下：
（1）抽象⽅法必须为public或者protected（因为如果为private，则不能被⼦类继承，⼦类便⽆法实现
该⽅法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠⼦类采⽤向上转型的⽅式处理；
（3）抽象类必须有⼦类，使⽤extends继承，⼀个⼦类只能继承⼀个抽象类；
（4）⼦类（如果不是抽象类）则必须覆写抽象类之中的全部抽象⽅法（如果⼦类没有实现⽗类的抽象⽅法，则必须将⼦类也定义为为abstract类。）；
范例：
package com.wz.abstractdemo;
abstract class A{//定义⼀个抽象类
public void fun(){//普通⽅法
System.out.println("存在⽅法体的⽅法");
}
public abstract void print();//抽象⽅法，没有⽅法体，有abstract关键字做修饰
}
//单继承
class B extends A{//B类是抽象类的⼦类，是⼀个普通类
@Override
public void print() {//强制要求覆写
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String[] args) {
A a = new B();//向上转型
a.fun();//被⼦类所覆写的过的⽅法
}
}
运⾏结果：
Hello World !
现在就可以清楚的发现：
（1）抽象类继承⼦类⾥⾯有明确的⽅法覆写要求，⽽普通类可以有选择性的来决定是否需要覆写；
（2）抽象类实际上就⽐普通类多了⼀些抽象⽅法⽽已，其他组成部分和普通类完全⼀样；
（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。
虽然⼀个类的⼦类可以去继承任意的⼀个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外⼀个普通类，⽽是去继承抽象类。
三、抽象类的使⽤限制
（1）抽象类中有构造⽅法么？
由于抽象类⾥会存在⼀些属性，那么抽象类中⼀定存在构造⽅法，其存在⽬的是为了属性的初始化。
并且⼦类对象实例化的时候，依然满⾜先执⾏⽗类构造，再执⾏⼦类构造的顺序。
范例如下：
abstract class A{//定义⼀个抽象类
public A(){
System.out.println("*****A类构造⽅法*****");
}
public abstract void print();//抽象⽅法，没有⽅法体，有abstract关键字做修饰
}
//单继承
class B extends A{//B类是抽象类的⼦类，是⼀个普通类
public B(){
System.out.println("*****B类构造⽅法*****");
}
@Override
public void print() {//强制要求覆写
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String[] args) {实例化类和实例化对象
A a = new B();//向上转型
}
}
执⾏结果：
*****A类构造⽅法*****
*****B类构造⽅法*****
（2）抽象类可以⽤final声明么？
不能，因为抽象类必须有⼦类，⽽final定义的类不能有⼦类；
（3）抽象类能否使⽤static声明？
先看⼀个关于外部抽象类的范例：
static abstract class A{//定义⼀个抽象类
public abstract void print();
}
class B extends A{
public void print(){
System.out.println("**********");
}
}
public class TestDemo {
public static void main(String[] args) {
A a = new B();//向上转型
a.print();
}
}
执⾏结果
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Illegal modifier for the class A; only public, abstract & final are permitted
at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)
再看⼀个关于内部抽象类：
package com.wz.abstractdemo;
abstract class A{//定义⼀个抽象类
static abstract class B{//static定义的内部类属于外部类
public abstract void print();
}
}
class C extends A.B{
public void print(){
System.out.println("**********");
}
}
public class TestDemo {
public static void main(String[] args) {
A.B ab = new C();//向上转型
ab.print();
}
}
执⾏结果：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。