- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

59_Java_面向对象5_abstract_interface_代理_工厂模式_内部类

alexsully 发表于 2021/06/02 21:01:20 2021/06/02

【摘要】 abstract interface 代理模式工厂模式内部类

抽象类 Abstract

abstract关键字的使用 : 子类定义越来越具体，父类更像一个通用类，为了保证父类/子类共享特征，将父类抽象化，父类不能实例化

1 abstract:抽象的

2 abstract可以用来修饰的结构：类、方法

3 abstract修饰类：抽象类

> 此类不能实例化 abstract class Creature{ public abstract void breath(); }

> 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）

> 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

4. abstract修饰方法：抽象方法

> 抽象方法只有方法的声明，没有方法体； public abstract void eat();

> 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。

> 若子类重写了父类中的所有的抽象方法后，此子类方可实例化 若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

5 abstract使用上的注意点：

1.abstract不能用来修饰：属性、构造器等结构; 构造器本身不能重写只能重载；

2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

Note: 抽象必须重写，私有方法无法重写；方法重写前提是非static的，final不能重写方法，类不能继承和抽象相对存在

abstract class Creature{    
public abstract void breath();
}

abstract class Person extends Creature{   // 没有重写父类的 breath() 所以是abstract 修饰
    String name;
    int age;
    public Person(){
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
		
	// 抽象方法
    public abstract void eat();
    public void walk(){
        System.out.println("人走路");
    }		
}


class Student extends Person{
    public Student(String name,int age){
        super(name,age);
    }
    public Student(){
    }
    
    public void eat(){    # 重写父类person 抽象 eat()
        System.out.println("学生多吃有营养的食物");
    }

    @Override
    public void breath() {   #  重写父类  creature  breath()                     
        System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
    }}

# 创建了一匿名子类的对象

 method1(new Person(){
            @Override
            public void eat() {
                System.out.println("吃好吃东西");
            }

            @Override
            public void breath() {
                System.out.println("好好呼吸新鲜空气");
            }
        });
    }

抽象类的应用：模板方法的设计模式

public class TemplateTest {
    public static void main(String[] args) {
        SubTemplate t = new SubTemplate();
        t.spendTime();
    }}

abstract class Template{
    //计算某段代码执行所需要花费的时间
    public void spendTime(){
        
        long start = System.currentTimeMillis();
        this.code();//不确定的部分、易变的部分
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));
    }
    public abstract void code();
}

class SubTemplate extends Template{
    @Override
    public void code() {
        for(int i = 2;i <= 1000;i++){
            boolean isFlag = true;
            for(int j = 2;j <= Math.sqrt(i);j++){
                
                if(i % j == 0){
                    isFlag = false;
                    break;
                } }
            if(isFlag){
                System.out.println(i);
            }
        }}}

接口的使用；可以实现多继承的效果

1.接口使用interface来定义

2.Java中，接口和类是并列的两个结构

3.如何定义接口：定义接口中的成员

3.1 JDK7及以前：只能定义全局常量和抽象方法

>全局常量：public static final的.但是书写时，可以省略不写

>抽象方法：public abstract的没有方法体

3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）

4. 接口中不能定义构造器的！意味着接口不可以实例化

5. Java开发中，接口通过让类去实现(implements)的方式来使用. 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

6. Java类可以实现多个接口 --->弥补了Java单继承性的局限性格式：class AA extends BB implements CC,DD,EE

7. 接口与接口之间可以继承，而且可以多继承

8. 接口的具体使用，体现多态性

9. 接口，实际上可以看做是一种规范

1.接口使用上也满足多态性

2.接口，实际上就是定义了一种规范

3.开发中，体会面向接口编程！

interface USB{
//常量：定义了长、宽、最大最小的传输速度等
    void start();
    void stop();
	}
	
class Flash implements USB{
    @Override
    public void start() {
        System.out.println("U盘开启工作");}

    @Override
    public void stop() {
        System.out.println("U盘结束工作");}}
		
class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");}

    @Override
    public void stop() {
        System.out.println("打印机结束工作");}}
		
class Computer{
    public void transferData(USB usb){//USB usb = new Flash();  // 接口定义规范， 但接口不能造对象，传入一个接口的实现类的对象； 体现了接口的多态性
        usb.start();
        System.out.println("具体传输数据的细节");
        usb.stop(); }}

public class USBTest {
    public static void main(String[] args) {
        Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);
        
        //2. 创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());
        
        //3. 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB(){   # 匿名实现类 没名，用接口来充当；
            @Override
            public void start() {
                System.out.println("手机开始工作");}

            @Override
            public void stop() {
                System.out.println("手机结束工作");}};
        com.transferData(phone);
        
        
        //4. 创建了接口的匿名实现类的匿名对象
        
        com.transferData(new USB(){
            @Override
            public void start() {
                System.out.println("mp3开始工作");}

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            } });}}

代理模式代理设计就是为其他对象提供一种代理以控制对这个对象的访问

//接口
interface Star {
    void confer();// 面谈
    void signContract();// 签合同
    void bookTicket();// 订票
    void sing();// 唱歌
    void collectMoney();// 收钱
}

//被代理类
class RealStar implements Star {
    public void confer() { }
    public void signContract() { }
    public void bookTicket() { }
    public void sing() {
        System.out.println("明星：歌唱~~~");}
    public void collectMoney() { }
}


//代理类
class Proxy implements Star {
    private Star real;
    public Proxy(Star real) {
        this.real = real;}

    public void confer() {
        System.out.println("经纪人面谈");}

    public void signContract() {
        System.out.println("经纪人签合同");}

    public void bookTicket() {
        System.out.println("经纪人订票");}

    public void sing() {
        real.sing();}

    public void collectMoney() {
        System.out.println("经纪人收钱"); }}


public class StaticProxyTest {
    public static void main(String[] args) {
        Proxy s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }}

工厂模式：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来

public class FactoryTest {
    public static void main(String[] args) {
        new AudiFactory().getCar().run();
        new MazdaFactory().getCar().run();
    }
}

interface Car {
    void run();
}

class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪");
    }
}

class Mazda implements  Car{    // 要被创建的对象
    @Override
    public void run() {
        System.out.println("马自达");
    }
}

class AudiFactory {   // 创建对象的工厂  OCP（开闭原则，Open-Closed Principle） 
    public Audi getCar (){
        return  new Audi();
    }
}
class MazdaFactory{
    public Mazda getCar(){
        return new Mazda();
    }
}

内部类

1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

2.内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)

3.成员内部类：

一方面，作为外部类的成员：

>调用外部类的结构

>可以被static修饰

>可以被4种不同的权限修饰

另一方面，作为一个类：

> 类内可以定义属性、方法、构造器等

> 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承

> 可以被abstract修饰

4.关注如下的3个问题

4.1 如何实例化成员内部类的对象

4.2 如何在成员内部类中区分调用外部类的结构

4.3 开发中局部内部类的使用

public class InnerClassTest {
    public static void main(String[] args) {

        //创建Dog实例(静态的成员内部类):
        Person.Dog dog = new Person.Dog();
        dog.show();
        //创建Bird实例(非静态的成员内部类):
//        Person.Bird bird = new Person.Bird();//错误的
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();

        System.out.println();
        bird.display("黄鹂");
    }}

class Person{

    String name = "小明";
    int age;

    public void eat(){
        System.out.println("人：吃饭");
    }

    //静态成员内部类
    static class Dog{
        String name;
        int age;

        public void show(){
            System.out.println("卡拉是条狗");
//            eat();
        }
    }
    //非静态成员内部类
    class Bird{
        String name = "杜鹃";

        public Bird(){

        }

        public void sing(){
            System.out.println("我是一只小小鸟");
            Person.this.eat();//调用外部类的非静态属性
            eat();
            System.out.println(age);
        }

        public void display(String name){
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的属性
            System.out.println(Person.this.name);//外部类的属性
        }
    }


    public void method(){
        //局部内部类
        class AA{

        }
    }

    {
        //局部内部类
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

59_Java_面向对象5_abstract_interface_代理_工厂模式_内部类

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

59_Java_面向对象5_abstract_interface_代理_工厂模式_内部类

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品