Java零基础也看得懂的单例模式与final及抽象类和接口详解

目录
  • 1.单例模式
    • 1.饿汉式和懒汉式的实现
    • 2.饿汉式
    • 3.懒汉式
    • 4.懒汉式和饿汉式的区别
  • 2.final的使用
    • 1.基本介绍
    • 2.使用场景
    • 3.使用注意事项和细节讨论
  • 3.抽象类
    • 1.基本介绍
    • 2.使用注意事项和细节讨论
  • 4.接口
    • 1.基本介绍
    • 2.注意事项和细节讨论
    • 3.实现接口与继承的区别
    • 4.接口与继承同时出现如何访问属性
    • 5.接口的多态特性

1.单例模式

1.饿汉式和懒汉式的实现

步骤:

  • 将构造器私有化
  • 类的内部创建对象
  • 向外暴露一个静态的公共方法

2.饿汉式

class School1 {
    //饿汉式
    private String name;
    //在类的内部直接创建对象
    private static School1 sc = new School1("清华大学");
    //将构造器私有化
    private School1(String name) {
        this.name = name;
    }
    //提供一个公共的static方法返回对象
    public static School getInstance() {
        return sc;
    }
}

3.懒汉式

class School2 {
    //懒汉式
    private String name;
    //在类的内部直接创建对象
    private static School2 sc;
    //将构造器私有化
    private School2(String name) {
        this.name = name;
    }
    //提供一个公共的static方法返回对象
    //若对象为null创建对象否则直接返回对象
    public static School2 getInstance() {
        if (sc == null) {
            sc = new School2("清华大学");
        }
        return sc;
    }
}

4.懒汉式和饿汉式的区别

  • 创建对象的时机不同:饿汉式在类加载是就创建了对象,懒汉式是在使用时再创建。
  • 饿汉式不存在线程安全问题,懒汉式存在线程安全问题。
  • 饿汉式在类加载是就创建了对象所以存在资源浪费的问题,但懒汉式就不存在这个问题。

2.final的使用

1.基本介绍

final可以修饰类,属性,方法和局部变量。

2.使用场景

①当不希望父类被继承。

②当不希望父类的方法被子类重写。

③当不希望类的某个属性被修改

④当不希望某个局部变量被修改

final class A{};//当不希望父类被继承。
class B{
    public final void display(){};//当不希望父类的方法被子类重写。
    public final int A_B = 10;//当不希望类的某个属性被修改
    public void show(){
        final int A_c = 20;//当不希望某个局部变量被修改
    }
}

3.使用注意事项和细节讨论

1.final修饰的属性又叫常量,一般用 XX_XX

2.final修饰的属性定义时,必须在以下位置赋初值

①定义时直接赋值。

②在构造器中赋值。

③在代码块中赋值。(普通属性在普通代码块初始化,静态属性在静态代码块初始化)

class A {
//  定义时直接赋值。
    public final  int a = 10;
//    {
//        a = 10;//在代码块中赋值。
//    }
//
//    public A() {
//        a = 10;//在构造器中赋值。
//    }
}

3.如果final修饰的属性是static,则初始化的为位置只能是

①定义时直接赋值。

②在静态代码块中赋值。

class A {
//  定义时直接赋值。
    public final static int a = 10;
//    static {
//        a = 10;//在静态代码块中赋值。
//    }
//    public A() {
//   final修饰的属性是static,则初始化的为位置不能是构造器
//        a = 10;
//    }
}

4.final类不能继承,但可以实例化对象。

5.final修饰的方法虽然不能重写,但可以被继承。

6.final不能修饰构造器。

7.final 和 static 搭配使用,不会导致类的加载,效率更高。

8.包装类(Integer,Double,Float,Boolean,String等都是final修饰的)

3.抽象类

1.基本介绍

用abstract关键字修饰的类叫抽象类,abstract还可以用来修饰一个方法,即抽象类。

abstract class A{
    abstract void display();
    //当一个类中有一个抽象方法,这个类也要定义为抽象类
}

2.使用注意事项和细节讨论

1.抽象类不能被实例化。

2.抽象类可以没有abstract方法。

3.当一个类中有一个抽象方法,这个类也要定义为抽象类。

4.abstract只能修饰类和方法,不能修饰属性和其他。

5.抽象类可以有任意成员,但抽象方法不能有实现主体。

6.如果一个类继承了抽象类,则必须要实现抽象类的所有方法。

7.抽象方法不能用private,static,final来修饰,因为这些关键字与重写相违背

4.接口

1.基本介绍

interface 接口名{
    //属性
    //方法(可以为抽象方法,静态方法,默认方法)
    //在JDk7.0之前接口的所有方法都为抽象方法
}
class 类名 implements 接口{
    自己属性;
    自己方法;
    必须实现的接口的抽象方法;

}

public interface UsbInterface {
    int a = 10;//实际上是public final static int a = 10;
    void connect();
    void close();//抽象方法
    default public void display(){//默认方法
        System.out.println("接口中的方法被调用~");
    }
    public static void show(){//静态方法
        System.out.println("接口中的静态方法被调用~");
    }
}

2.注意事项和细节讨论

1.接口不能被实例化

2.接口中所有的方法时 public 方法,接口中抽象方法,可以不用 abstract 修饰

3.一个普通类实现接口。就必须将该接口的所有方法都实现,可以使用alt+enter来解决

4.抽象类去实现接口时,可以不实现接口的抽象方法。

5.当一个类实现了一个接口,这个类就可以调用接口中的所有属性和默认方法,但不能调用接口中的静态方法。

public class MySql implements UsbInterface{
    @Override
    public void connect() {
        System.out.println("MySql被调用");
        display();
        System.out.println(a);
    }
    @Override
    public void close() {
        System.out.println("MySql被关闭");
    }
}

3.实现接口与继承的区别

1.继承是将父类的所有继承过来,子类天生就拥有父类的所有属性,实现接口就像是后天学习其他的没有的技能。

2.继承的价值主要在于:解决代码的复用性和可维护性。

3.接口的价值主要在于:设计规范。更加灵活。

4.继承是满足is-a的关系,接口只需满足like-a的关系。

5.接口在一定程度上实现了代码解耦。

4.接口与继承同时出现如何访问属性

public class Interface01 {
}
interface A{
    int x = 10;
}
class B {
    int x = 20;
}
class C extends B implements A{
    public void display(){
        System.out.println( A.x + "+" + super.x );
    }
    //接口的属性直接通过接口名访问,父类通过super访问
    public static void main(String[] args) {
        new C().display();
    }
}

5.接口的多态特性

1.多态参数

接口可以接受不同的对象,接口的引用也可以指向实现了接口的类的对象。

public class InterfaceDetails {
    public static void main(String[] args) {
        MySql mySql = new MySql();
        Oracle oracle = new Oracle();
        t(mySql);
        t(oracle);
       UsbInterface UIf = mySql;
    }
    public static void t(UsbInterface mb) {
        mb.close();
        mb.connect();
    }
}

2.多态数组

public interface UsbInterface {
    void work();
}
public class Phone implements UsbInterface{
    @Override
    public void work() {
        System.out.println("手机正在工作。。。");
    }
    public void call(){
        System.out.println("手机正在打电话。。。");
    }
}
public class Camera implements UsbInterface{
    @Override
    public void work() {
        System.out.println("相机正在工作。。。");
    }
}
public class Interface02 {
    public static void main(String[] args) {
        UsbInterface[] uIF = new  UsbInterface[2];
        Phone phone = new Phone();
        Camera camera = new Camera();
        uIF[0]= phone;
        uIF[1]= camera;
        for (int i = 0; i < 2; i++) {
            uIF[i].work();
            if(uIF[i] instanceof Phone){
                ((Phone) uIF[i]).call();
            }
        }
    }
}

3.接口存在多态传递现象

interface AA{
    void display();
}
interface BB extends AA{
}
class CC implements BB{
    @Override
    public void display() {
    }
} 

到此这篇关于Java零基础也看得懂的单例模式与final及抽象类和接口详解的文章就介绍到这了,更多相关Java单例模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 从内存模型中了解Java final的全部细节

    目录 从内存模型中了解final JMM 重排序 final域重排序规则 final对象是引用类型

  • Java十分钟快速掌握单例模式

    目录 前言 1.什么是单例模式: 2.单例模式的优缺点: 3.懒汉模式(比较常用) 4.饿汉模式[推荐使用] 5.单例模式的应用场景 6.单例模式的应用实例 小结: 前言 首先在Java中有23种设计模式: 创建型模式: 工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式结构型模式: 适配器模式.装饰者模式.代理模式.外观模式.桥接模式.组合模式.享元模式行为型模式::策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释

  • Java 设计模式以虹猫蓝兔的故事讲解单例模式

    目录 专栏介绍 本期介绍 什么是单例模式 懒汉式一 正常模式 单例模式 为什么线程不安全呢 懒汉式二 为什么线程安全呢 饿汉式 懒汉式与饿汉式的区别 专栏介绍 [JAVA长虹键法] 主要讲了23种设计模式,本系列专栏会以虹猫蓝兔七侠传的故事为例来给大家详细分析所有模式,希望能给大家带来帮助! 本期介绍 模式: 单例模式 案例: 虹猫蓝兔造剑 什么是单例模式 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的

  • Java基础巩固抽象类与接口详解

    目录 1.抽象类 1.1.什么是抽象类 1.2.抽象类的用法 1.3.抽象类特点(限制条件) 2.接口 2.1.什么是接口 2.2.接口的用法 2.3.如何使用接口 2.4.接口的特点(限制条件) 2.5.如何实现多个接口 2.6.接口于接口之间的继承关系 2.7.如何使用接口 抽象类与接口 1.抽象类 1.1.什么是抽象类 如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类 1.2.抽象类的用法 一个类如果被 abstract 修饰称为抽象类,抽象类中被 abstract

  • Java超详细讲解设计模式之一的单例模式

    目录 单例模式 1.单例模式的结构 2.单例模式的实现 2.1饿汉式 2.2懒汉式 3.单例模式的破坏 3.1序列化和反序列化 3.2反射 单例模式 单例模式顾名思义就是单一的实例,涉及到一个单一的类,该类负责创建自己的对象,同时确保只有一个对象被创建,并且提供一种可以访问这个对象的方式,可以直接访问,不需要实例化该类的对象. 单例模式的特点: 1.单例类只能有一个实例 2.这个实例必须由单例类自己创建 3.单例类需要提供给外界访问这个实例 单例模式的作用: 单例模式主要为了保证在Java应用程

  • Java中常用的设计模式之单例模式详解

    目录 注意 优点 缺点 使用场景 一.实现方式 二.实现方式 三.测试 总结 注意 1.单例类只能有一个实例. 2.单例类必须自己创建自己的唯一实例. 3.单例类必须给所有其他对象提供这一实例. 优点 1.在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存). 2.避免对资源的多重占用(比如写文件操作). 缺点 1.没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化. 使用场景 1.要求生产唯一序列号. 2.WE

  • Java超详细介绍抽象类与接口的使用

    目录 1.抽象类的语法和特性 1.1语法 1.2特性 2.接口的语法和使用 2.1语法 2.2特性 1.抽象类的语法和特性 1.1语法 1.在Java中,一个类如果被abstract 修饰称为抽象类,抽象类中被 abstract 修饰的方法称为抽象方法,抽象方法不用给出具体的实现体. // 抽象类:被abstract修饰的类 public abstract class Shape { // 抽象方法:被abstract修饰的方法,没有方法体 abstract public void draw()

  • Java零基础也看得懂的单例模式与final及抽象类和接口详解

    目录 1.单例模式 1.饿汉式和懒汉式的实现 2.饿汉式 3.懒汉式 4.懒汉式和饿汉式的区别 2.final的使用 1.基本介绍 2.使用场景 3.使用注意事项和细节讨论 3.抽象类 1.基本介绍 2.使用注意事项和细节讨论 4.接口 1.基本介绍 2.注意事项和细节讨论 3.实现接口与继承的区别 4.接口与继承同时出现如何访问属性 5.接口的多态特性 1.单例模式 1.饿汉式和懒汉式的实现 步骤: 将构造器私有化 类的内部创建对象 向外暴露一个静态的公共方法 2.饿汉式 class Scho

  • Java中的多态、抽象类和接口详解

    目录 1.多态 1.1 向上转型 1.2 向下转型 1.3 实现多态的条件 1.4多态的特点与使用 1.5多态的应用 以父类类型作为方法的参数 使用父类型作为方法的返回值 1.6 多态的注意点 2.抽象类 2.1 abstract关键字 2.2 抽象方法和普通方法的区别 2.3 抽象类和普通类的区别 2.4 本质 2.5 抽象类局限 3.接口 3.1 定义接口 3.2 使用接口 3.3 实现多个接口 3.4 jdk8接口新特性 1.多态 一个特定类型的变量,可以引用多个不同类型的对象,并且能自动

  • Java零基础讲解异常

    目录 什么是异常? 异常的处理 异常的抛出 处理异常 throws声明异常 捕获异常 finally: 异常的处理流程 自定义异常 什么是异常? 异常在我们写代码是特别常见,因为程序员大部分时间都在修复bug,在java中通过throwable顶层类又可以分为两个,一个是Error(错误),一个是Exception(异常). Error(错误) : Error与异常不同的是,错误并不能处理,而是程序员造成的问题,比如语法错误那就要程序员检查自己的语法,比如结果错误(StackOverflowEr

  • Java零基础教程之Windows下安装、启动Tomcat服务器方法图解(免安装版)

    相关阅读: Java零基础教程之Windows下安装 JDK的方法图解 官网下载 你是 Windows 环境,所以,打开浏览器,输入地址:http://tomcat.apache.org/download-70.cgi 选择对应的 ..-bit Windows zip下载就可以了. 安装 找到你下载的 ZIP 包,解压到你认为合适的目录,其实这是免安装版. 启动 进入 bin 目录,找到startup.bat双击,这样就算启动了 Tomcat 了,现在在浏览器输入地址+端口8080(默认)即可看

  • Java零基础教程之Windows下安装 JDK的方法图解

    官网下载 直接打开官网:http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html 我安装的是 1.7 版本,当然,你可以选择自己合适版本. 安装 下载的是.exe文件,没什么好讲的,都是直接下一步下一步.当然,你可以选择合适的安装路径,我选择了F:\Java. 接着选择jre安装路径: 环境变量 桌面上找到 计算机(此电脑)右键,点击属性--高级系统设置--环境变量,就可以开始编辑了.

  • Java零基础入门数组

    目录 认识数组 数组的初始化 默认初始化 静态初始化 动态初始化 数组有关的问题 数组的遍历 求最值问题 查询子元素 Arrays工具类 二维数组 二维数组初始方式 二维数组的遍历 认识数组 数组的定义 数组是相同类型数据的有序集合.数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成.其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们. 数组的四个基本特点 长度是确定的.数组一旦被创建,它的大小就是不可以改变的. 其元素的类型必须是相同类型,不允许出现混合类型

  • Java零基础精通方法篇

    目录 一.前言 二.定义与调用 1.概述 2.格式 3.调用 4.注意 三.范例 1. 例题 1 2. 例题 2 3. 例题 3 四.方法调用的内存图 五.重载 1.概述 2.例题 3.总结 一.前言 学习概述:学习四种不同类型的方法应用.方法被调用时的内存图.重载 学习目标:熟练掌握方法的应用以及重载 二.定义与调用 1.概述 定义:方法是一种语法结构,把一段代码封装成一个功能,方便重复调用 分类:一般分为参数(带/不带).返回值(有/无) 好处:提高代码复用性.逻辑更加清晰 2.格式 修饰符

  • Java基础学习之接口详解

    目录 概述 定义格式 含有抽象方法 含有默认方法和静态方法 含有私有方法和私有静态方法 基本的实现 实现的概述 抽象方法的使用 默认方法的使用 静态方法的使用 私有方法的使用 接口的多实现 抽象方法 默认方法 静态方法 优先级的问题 接口的多继承 其他成员特点 概述 接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量.构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法 (JDK 9). 接

  • java 抽象类的实例详解

    java 抽象类的实例详解 前言: 什么是抽象类?这名字听着就挺抽象的,第一次听到这个名字还真有可能被唬住.但是,就像老人家所说的,一切反动派都是纸老虎,一切有着装x名字的概念也是纸老虎.好吧,我们已经从战略上做到了藐视它,现在就要战术上重视它,如同要解决纸老虎,就要一个牙齿一个牙齿地敲,一个爪子一个爪子地拔:解决这种抽象概念也一样,先要把它具体化,细分化,然后一个一个地来. 我一般遇到新的概念都会问三个问题: 1.这个东西有什么用?用来干什么的?它的意义在哪里?(显然,如果是没用的东西,就没必

随机推荐