abstract
引出-案例
package com.ujiuye.day11;
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;
package com.ujiuye.day11;
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 这两个抽象方法了
}
案例4: 关于特点3
package com.ujiuye.day11;
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
package com.ujiuye.day11;
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:
package com.ujiuye.day11;
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种.
模版设计模式
把抽象类整体看成是一个模板，模板中不能决定的东西使用抽象方法表示，让使用模板的类【抽象类的子类】去重写抽象方法实现需求
设计模式案例
```java
模拟一个用天然气做热菜的场景
开火
//确定不了 ----> 使用抽象方法表示
关火
package com.ujiuye.day11;
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("使用的是爆炒的方法");
}
}
```