abstract
引出-案例
public class Demo1 {
public static void main(String[] args) {
Shape shape = new Shape();//對象 在現實生活中存在嗎? 高度抽象的類
//在現實中 存在的對象都是其 子類的對象
}
}
abstract class Shape{
//圖形類
// 以下的這兩個方法 的方法實現 不寫不行 寫了沒有 --> 尷尬
//抽象方法
public abstract double area();
public abstract double girth();
//非抽象方法
public void m(){
System.out.println("我是一個非抽象方法");
}
//構造方法
public Shape(){
System.out.println("我是抽象類中的構造方法");
}
}
概述
抽象的意思
可以修飾的內容
1、類
2、方法
抽象類
概念： 被 abstract 修飾的類稱為抽象類
語法：
public abstract class 抽象類類名{}
抽象方法
抽象⽅法 ： 被abstract 修飾的⽅法
語法：
訪問修飾符 abstract 返回值類型 ⽅法名（參數列表）；
abstract 訪問修飾符 返回值類型 ⽅法名（參數列表）；
特點
1、當⼀個類中存在抽象⽅法 那么這個類也必須是抽象的
2、⼀個抽象類中可以有抽象⽅法也可以有⾮抽象⽅法(抽象類中可以定義任何的成員 屬性 構造方法 成員方法 抽象方法)
3、如果⼀個類繼承了抽象類，這個類如果不想成為抽象類，那么這個類必須實現抽象類中的所有抽象⽅法
4、抽象類不能創建對象，但是可以聲明引⽤，抽象類的對象是存在的，是由⼦類創建⼦類對象時調⽤⽗類構造⽅法創建的，是⽆法⾃⼰⼿動去new 抽象類的對象的
5、private 和 abstract 不同同時修飾方法 因為矛盾
特點-案例
//案例1: 關於特點3;
public class Demo1 {
public static void main(String[] args) {
}
}
//定義一個抽象類
abstract class TestAbstract{
//構造方法
public TestAbstract() {
System.out.println("我是抽象類中的構造方法");
}
//定義抽象方法
public abstract void m1();
public abstract void m2();
//定義非抽象方法
public void m3(){
System.out.println("我是抽象類中的非抽象方法 m3");
}
}
//定義一個類 繼承 抽象類
abstract class TestClass extends TestAbstract{
//當子類成為抽象類的時候 就沒有必要去實現 m1 和 m2 這兩個抽象方法了
}
//案例2: 關於特點3
public class Demo1 {
public static void main(String[] args) {
TestClass testClass = new TestClass();
testClass.m3();//m3 非抽象方法被繼承了
}
}
//定義一個抽象類
abstract class TestAbstract{
//構造方法
public TestAbstract() {
System.out.println("我是抽象類中的構造方法");
}
//定義抽象方法
public abstract void m1();
public abstract void m2();
//定義非抽象方法
public void m3(){
System.out.println("我是抽象類中的非抽象方法 m3");
}
}
//定義一個類 繼承 抽象類
class TestClass extends TestAbstract{
public TestClass(){
super();
}
@Override
public void m1() {
System.out.println("我是子類重寫抽象類后的m1");
}
@Override
public void m2() {
System.out.println("我是子類重寫抽象類后的m3");
}
//重寫 m3 方法
@Override
public void m3() {
System.out.println("我是子類重寫抽象類的非抽象方法 m3");
}
}
//案例3: 關於特點4
public class Demo1 {
public static void main(String[] args) {
//TestAbstract testAbstract;//聲明引用
// TestAbstract testAbstract = new TestAbstract();// 不能創建抽象類的對象
//抽象類的對象存在
TestClass testClass = new TestClass();
testClass.m3();
}
}
//定義一個抽象類
abstract class TestAbstract{
int a = 10;
//構造方法
public TestAbstract() {
System.out.println("我是抽象類中的構造方法");
}
//定義抽象方法
public abstract void m1();
public abstract void m2();
//定義非抽象方法
public void m3(){
System.out.println("我是抽象類中的非抽象方法 m3");
}
}
//定義一個類 繼承 抽象類
class TestClass extends TestAbstract{
int a = 20;
public TestClass(){
super();
}
@Override
public void m1() {
System.out.println("我是子類重寫抽象類后的m1");
}
@Override
public void m2() {
System.out.println("我是子類重寫抽象類后的m3");
}
//重寫 m3 方法
@Override
public void m3() {
System.out.println(a);
System.out.println(super.a);//super 當前類的直接父類對象的引用
System.out.println("我是子類重寫抽象類的非抽象方法 m3");
}
}
//案例4:
public class Demo1 {
public static void main(String[] args) {
//TestAbstract testAbstract;//聲明引用
// TestAbstract testAbstract = new TestAbstract();// 不能創建抽象類的對象
//抽象類的對象存在
// TestClass testClass = new TestClass();
// testClass.m3();
TestAbstract testAbstract = new TestClass();// 父類引用指向子類對象
testAbstract.m1();
testAbstract.m2();
testAbstract.m3();
}
}
//定義一個抽象類
abstract class TestAbstract{
int a = 10;
//構造方法
public TestAbstract() {
System.out.println("我是抽象類中的構造方法");
}
//定義抽象方法
public abstract void m1();
public abstract void m2();
//定義非抽象方法
public void m3(){
System.out.println("我是抽象類中的非抽象方法 m3");
}
}
//定義一個類 繼承 抽象類
class TestClass extends TestAbstract{
int a = 20;
public TestClass(){
super();
}
@Override
public void m1() {
System.out.println("我是子類重寫抽象類后的m1");
}
@Override
public void m2() {
System.out.println("我是子類重寫抽象類后的m2");
}
//重寫 m3 方法
@Override
public void m3() {
System.out.println(a);
System.out.println(super.a);//super 當前類的直接父類
System.out.println("我是子類重寫抽象類的非抽象方法 m3");
}
public void m4(){
System.out.println("我是子類特有的方法m4");
}
}
模版設計模式
設計模式
設計模式: 就是在實際開發中,總結的一套解決問題的固定套路,經過總結,最后就形成了設計模式 23種.
模版設計模式
把抽象類整體看成是一個模板，模板中不能決定的東西使用抽象方法表示，讓使用模板的類【抽象類的子類】去重寫抽象方法實現需求
設計模式案例
模擬一個用天然氣做熱菜的場景
開火
//確定不了 ----> 使用抽象方法表示
關火
public class Demo1 {
public static void main(String[] args) {
Case tomatoEgg = new TomatoEgg();
tomatoEgg.doFood();
}
}
abstract class Case{
//做菜的方法
public void doFood(){
onFire();
// 不能確定的步驟
perpareVegetable();
shaoYou();
makeType();
offFire();
}
// 備菜
public abstract void perpareVegetable();
// 燒油
public abstract void shaoYou();
// 做法
public abstract void makeType();
//做熱菜 確定的方法
public void onFire(){
System.out.println("開火");
}
public void offFire(){
System.out.println("關火");
}
}
//做不同的菜
class TomatoEgg extends Case{
@Override
public void perpareVegetable() {
System.out.println("准備西紅柿 切成塊");
System.out.println("准備雞蛋 打成蛋液");
System.out.println("准備蔥姜蒜");
}
@Override
public void shaoYou() {
System.out.println("使用的是橄欖油加 500g");
}
@Override
public void makeType() {
System.out.println("使用的是爆炒的方法");
}
}
