59_Java_面向对象5_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{ } }

Java

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。