Java基础知识记录(二)

最新推荐文章于 2019-10-03 22:56:19 发布

你走开``

最新推荐文章于 2019-10-03 22:56:19 发布

阅读量360

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_34531925/article/details/79098208

版权

java基础专栏收录该内容

59 篇文章 0 订阅

订阅专栏

抽象类
1. 抽象类的使用原则如下：
  （1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
  （2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
  （3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
  （4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
2. 抽象类的特点
  1. 抽象类依然有构造方法,用于其成员变量与成员方法的初始化
  2. 抽象类不能被abstract所修饰 , 因为冲突
  3. 外部抽象类不能被static修饰, 内部抽象类可以.
  4. 抽象类其他方面,与普通类一样. 静态成员变量也可以使用类名进行调用.
3. 抽象类的应用 –模板设计模式 – 参考链接 : http://blog.csdn.net/wei_zhi/article/details/52736350
4. 接口与抽象类或者普通类相比的优势 : 接口可以多实现, 更容易扩展. 接口内是由抽象方法组成,没有方法体,对外提供服务更加方便.. 而且更容易实现松耦合
接口
1. 组成
  1. 接口时由抽象方法与全局常量组成的特殊的类,连构造方法都没有.
2. 使用原则
  （1）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口；
  （2）接口的子类（如果不是抽象类），那么必须要覆写接口中的全部抽象方法；
  （3）接口的对象可以利用子类对象的向上转型进行实例化。
  （4）接口中的访问权限只有一种：public
  （5）静态final成员变量和成员抽象方法的修饰词统统可以省略
3. 继承关系
  （1）一个抽象类只能继承一个抽象父类，而接口可以继承多个接口；
  （2）一个子类只能继承一个抽象类，却可以实现多个接口（在Java中，接口的主要功能是解决单继承局限问题）
4. 利用接口对外提供规则.
  1. 自定义可供外使用的接口
    如果要进行开发，要先开发出USB接口标准，然后设备厂商才可以设计出USB设备。
    现在假设每一个USB设备只有两个功能：安装驱动程序、工作。
    定义一个USB的标准：

interface USB {   // 操作标准       
    public void install() ;
    public void work() ;
}

在电脑上应用此接口：

class Computer {
   public void plugin(USB usb) {
          usb.install() ;
          usb.work() ;
      }
}

然后接口实现者 可以根据自己的需要自定义接口实现.

完全解耦
1. 方法在指定接收参数为类时, 本质上已经限制了该方法接收的类只能是该类或者该类的子类. 反而如果接收参数是接口, 那么则不存在该限制. 具有良好的扩展性.
2. 情况
1.情况可控时

package org.interfaces;
import java.util.Arrays;
class Processor {
    public String name() {
        return getClass().getName();
    }   
    Object process(Object input) {
        return input;
    }
}
class Upcase extends Processor{
    String process(Object input){
        return ((String)input).toUpperCase();
    }
}
class Downcase extends Processor{
    String process(Object input){
        return ((String)input).toLowerCase();
    }
}
class Splitter extends Processor{
    String process(Object input){
        return Arrays.toString(((String)input).split(" "));
    }
}
// 多态,实现了代码的复用性. 但是在 Apply类中的通用处理器,只是针对Processor的通用处理器类,并不能实现扩展. 
// 也就是说, Apply与Processor并没有实现真正的解耦
class Apply{
    public static void process(Processor p,Object s){
        System.out.println("Using Processor"+p.name());
        System.out.println(p.process(s));
    }
    public static String s="this is a Sup--Sub Coupling";
    public static void main(String[] args){
        process(new Upcase(),s);
        process(new Downcase(),s);
        process(new Splitter(),s);
    }
}

改进后

    package org.interfaces.interfaceprocess;
// 接口处理器
public interface Processor {
    String name();
    Object process(Object input);
}
    package org.interfaces.interfaceprocess;
public abstract class StringProcessor implements Processor{
    @Override
    public String name() {
        return getClass().getName();
    }
    @Override
    public abstract Object process(Object input);
}
class Upcase extends StringProcessor{
    public String process(Object input) {
        return "1";
    }
}
class Downcase extends StringProcessor{
    public String process(Object input) {
        return "2";
    }
}
class Splitter extends StringProcessor{
    public String process(Object input) {
        return "3";
    }
}
// 此种, 以接口为参数,就可以实现更好的扩展. 
// 同时, 其他各种具体扩展器实现继承接口的抽象子类, 既复用代码,又约定了规则.
class Apply {
     public static void process(Processor p,Object s){
            System.out.println("Using Processor"+p.name());
            System.out.println(p.process(s));
        }
        public static String s="this is a Sup--Sub Coupling";
        public static void main(String[] args){
            process(new Upcase(),s);
            process(new Downcase(),s);
            process(new Splitter(),s);
        }
}

适配器模式实现完全解耦 ->
1. 改造前

    package org.interfaces.filter;

// 波形 ->处理对象
public class Waveform {
    private static long counter; //计数
    private final long id = counter++; //ID
    public String toString() {return "Waveform:" +id;}
}
// 过滤器基类
public class Filter { 
    public String name() {
        return getClass().getName();
    }
}
// 过滤器实现
public class LowPass extends Filter{
    double cutoff; //截止值
    public LowPass(double cutoff) {
        this.cutoff = cutoff;
    }
    // 这种方式只针对Waveform类, 依赖性太强. 毫无扩展性
    public Waveform process(Waveform input) {
        return input;
    }
}
public class HighPass extends Filter{
    double cutoff; //截止值
    public HighPass(double cutoff) {
        this.cutoff = cutoff;
    }
    public Waveform process(Waveform input) {
        return input;
    }
}
public class BandPass extends Filter{
    double lowcutoff,highcutoff; // 底截止, 高截止
    public BandPass(double lowcutoff, double highcutoff) {
        super();
        this.lowcutoff = lowcutoff;
        this.highcutoff = highcutoff;
    }
    public Waveform process(Waveform input) {
        return input;
    }
}
// 此代码复用性极差, 只对一种对象做处理. 而且假设该对象是别人提供代码, 不能修改或者修改会引发隐患.

// 改造后

    上方代码不变
    增加了一个适配器,如下代码所示
    package org.interfaces.filter.adaper;
import org.interfaces.filter.Filter;
import org.interfaces.filter.Waveform;
import org.interfaces.interfaceprocess.Processor;
// 适配器 -> 对过滤器进行包装
// 所以,要有被包装的对象.->其基类即可
// processor -> 通用的实现可扩展的过滤器类
// 通过适配器包装其他不通用的过滤器,其实内部还是调用了该过滤器的具体方法.从而实现了过滤器的完全耦合.
public class FilterAdapter implements Processor{
    Filter filter;
    public FilterAdapter(Filter filter) {
        // 传进来过滤器,对其进行包装
        this.filter = filter;
    }
    @Override
    public String name() {
        return filter.name();
    }
    // 利用协变返回方式 窄化返回值
    @Override
    public Waveform process(Object input) {
        return filter.process((Waveform)input);
    }
}
// 接口的完全解耦经验总结 : 为实现可扩展,定义为以接口为参数的方式.

Java的多重继承
1. 多重继承指的是接口的多重继承. 对于普通类或者抽象类,Java只能单继承.
2. 项目在其包时,不得携带Java关键字或敏感子. 如Java
3. Java多重继承实现更好扩展性的实例

    package think;
/** 
 * @Description TODO
 * @author Cai
 * @date 2018年1月19日 上午9:31:51 
 * @version V1.0
 */

public interface CanFly{
    void fly();
}
interface CanSwim{
    void swim();
}
interface CanSing{
    void sing();
}
class Hero implements CanFly,CanSing,CanSwim {
    @Override
    public void swim() {
        System.out.println("swim");
    }
    @Override
    public void sing() {
        System.out.println("sing");
    }
    @Override
    public void fly() {
        System.out.println("fly");
    }
}
class DiaoYong {
    /*public static void swim(Filter filter) {
        // 此种方式,需要向下转型,不易于扩展,
    }*/
    public static void swim(CanSwim swim) {
        swim.swim();
    }
    public static void sing(CanSing sing) {
        sing.sing();
    }
    public static void fly(CanFly fly) {
        fly.fly();
    }
    public static void main(String[] args) {
        Hero hero = new Hero();
        swim(hero);
    }
}
// 注释: 每个接口都去实现一个空的接口, 用以增强代码的复用性. 因为超类作为参数,Java有一种参数绑定机制,前期绑定与后期绑定. 其会自动定位到其引用的子类并调用其子类的重写的方法.
// 2. 如果需要对该接口进行扩展,不建议对该接口进行增加方法,因为可能对其已经使用的子类产生印象. 只需重新创建一个接口,对该接口进行实现然后进行开发即可.

继承的缺点
1. 如果父类有私有的成员变量, 那么其子类不能继承, 且不能重写该方法.
2. 关于类的域的问题(域,即是成员变量)
  1. 如果基类与其子类有同样的公有的成员变量. 会出现如下的情况

    public class Father {
    String id = "father";
    public String getId() {
        return id;
    }
    public static void main(String[] args) {
        Father father = new son();
        System.out.println("father.id="+father.id+";getId="+father.getId());
        son son = new son();
        System.out.println("son.id="+son.id+";getId="+son.getId());
        System.out.println("getSuperId="+son.getSuperId());
    }
}
class son extends Father {
    String id = "son";
    public String getId() {return id;}
    public String getSuperId() {return super.id;}
}
运行结果
father.id=father;getId=son
son.id=son;getId=son
getSuperId=father
// 总结:
1. 由于域不是多态. 所以,如果是父类引用, 则如果访问该变量, 则访问的域是父类变量. 如果创建的是子类引用, 访问域, 则访问的是子类的变量
2. 由于方法时多态的. 所以, 访问的终究是子类的方法.

接口与工厂模式

    // 工厂模式
interface ServiceFactory{
    Service getService();
}
class Implemention1Factory implements ServiceFactory {
    public Service getService() {
        return new Implemention1();
    }
}
class Implemention2Factory implements ServiceFactory {
    public Service getService() {
        return new Implemention2();
    }
}
interface Service {
    void method1();
    void method2();
}
// 实现服务
class Implemention1 implements Service {
    public void method1() {
        System.out.println("Implemention1.method1");
    }
    public void method2() {
        System.out.println("Implemention1.method2");
    }
}
class Implemention2 implements Service {
    public void method1() {
        System.out.println("Implemention2.method1");
    }
    public void method2() {
        System.out.println("Implemention2.method2");
    }
}
public class Factories {
    // 工厂模式.
    // 通过具体服务实现继承该模块实现服务接口. 便于定义规则统一管理.且易于扩展
    // 调用该工厂
    // 服务消费端口.接收工厂
    // 此模式有一个弊端. 那就是每次出现一个新的工厂需求.就需要添加一个新的工厂与工厂实现.
    public static void serviceConsumer(ServiceFactory fact) {
        Service service = fact.getService();
        service.method1();
        service.method2();
        // 对于方法内部实现,并不清楚. 实现了服务与实现的完全分离.
    }
    public static void main(String[] args) {
        serviceConsumer(new Implemention1Factory());
        serviceConsumer(new Implemention2Factory());
    }
}

你走开``

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识记录(二)

抽象类抽象类的使用原则如下：（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；（4）子类（如果不是抽象类）则必须覆写抽象类之中的
复制链接

扫一扫

专栏目录