(六)java的static、final、单例模式、接口和匿名内部类

于 2023-07-24 19:57:40 发布
阅读量146 收藏
点赞数
分类专栏： Step1 文章标签： java 单例模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55439500/article/details/131902635
版权

目录

1. static

  • 使用范围：可用static修饰属性，方法，代码块，内部类
  • 被修饰后的成员具备以下特点：
    • 随着类的加载而加载
    • 优先于对象存在
    • 修饰的成员，被所有对象所共享
    • 访问权限允许时，可不创建对象，直接被类调用
  • 类方法，类中使用static修饰的方法
    • 没有对象的实例时，可以用类名.方法名()的形式访问由static 修饰的类方法
    • 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构
    • 因为不需要实例就可以访问static方法，因此static方法内部不能有this和super
    • static修饰的方法不能被重写
//探究static的使用和准则
public class Chinese {
    private String name;
    private int age;
    public static String nation = "大中国";//静态变量
    public void f1(){
        System.out.println("f1()");
    }
    public static void f2(){
        System.out.println("f2()");
    }
    public static void show(){
        System.out.println("自我介绍" + nation);
        f2();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}//测试部分：
public class Test1 {
    public static void main(String[] args) {
        Chinese malong = new Chinese();
        malong.setAge(32);
        malong.setName("马龙");
        malong.nation = "中华人民共和国";
        Chinese yaoming  = new Chinese();
        yaoming.setAge(34);
        yaoming.setName("姚明");
        yaoming.nation = "中国";
        System.out.println(malong.getName());
        System.out.println(malong.nation);//一般不这么用，静态方法直接使用:类名 + 成员名
        System.out.println(Chinese.nation);
        Chinese.show();//静态方法
    }
}

1.1 static的流程图

请添加图片描述

2. 单例模式

单例模式：要求程序中某一组件，在程序运行的整个生命周期中，只有一个实例
单例模式有两种：饿汉式，懒汉式
步骤如下：

  • 构造函数私有化，外面的组件不能主动创建这个对象
  • 提供静态方法返回对象实例，返回的是静态实例，所以只有一个实例

2.1 饿汉式

  • 好处：线程安全
  • 坏处：加载时，时间比较长

2.2 懒汉式

存在线程安全问题，没有静态初始化

饿汉式：//探究单例模式
public class HungerSingleton {
    private HungerSingleton() {//构造函数私有化
        System.out.println("HungerSingleton初始化...");
    }
    private static HungerSingleton instance = new HungerSingleton();//在方法区新建一个对象
    public static HungerSingleton getInstance() {//静态方法，返回实例对象
        return instance;
    }
}
  懒汉式：
public class LazySingleton {
    private LazySingleton() {//构造函数私有化
        System.out.println("LazySingleton被调用...");
    }
    private static LazySingleton instance = null;//实例对象先设为空，如果要使用在new
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
测试部分
public class Test1 {
    public static void main(String[] args) {
        //饿汉式
        HungerSingleton s1 = HungerSingleton.getInstance();//调用HungerSingleton的静态方法getInstance
        HungerSingleton s2 = HungerSingleton.getInstance();
        HungerSingleton s3 = HungerSingleton.getInstance();

        //懒汉式：在方法区懒得初始化，所以叫懒汉式
        LazySingleton n1 = LazySingleton.getInstance();//调用LazySingleton的静态方法getInstance
        LazySingleton n2 = LazySingleton.getInstance();
        LazySingleton n3 = LazySingleton.getInstance();
    }
}

2.3 饿汉式JMM状态

请添加图片描述

3. 代码化和初始化顺序

顺序：

  • 静态初始化(先进行父类的初始化，再进行子类初始化)
  • 父类代码块初始化、构造函数
  • 子类代码块初始化、构造函数
//探究代码块和初始化顺序
public class Paent {
    public int i = 10;//初始化
    {//代码块
        System.out.println("parent初始化代码块1");
    }
    {//代码块
        System.out.println("parent初始化代码块2");
    }

    public static int i2 = 0;//静态初始化
    static{//静态代码块
        System.out.println("parent静态初始化代码块1");
    }
    static{//静态代码块
        System.out.println("parent静态初始化代码块2");
    }

    public Paent() {
        System.out.println("parent构造函数。。。");
    }
}

/*初始化顺序
1.静态初始化
2，初始化代码、构造函数。
如果有父类，先进行 父类静态-->子类静态 -->父类初始化代码块、构造函数-->子类初始化代码块、构造函数
 */
public class Children extends Paent {
    public int i = 20;
    {//代码块
        System.out.println("Children初始化代码块1");
    }
    
    {//代码块
        System.out.println("Children初始化代码块2");
    }
    static{//静态代码块
        System.out.println("Children静态初始化代码块1");
    }
    static{//静态代码块
        System.out.println("Children静态初始化代码块2");
    }

    public Children() {
        System.out.println("Children构造函数。。。");
    }

    public static void main(String[] args) {
        Children children = new Children();
    }
}

4. final关键字

  • 修饰类：表示类不能被继承
  • 修饰方法：表示方法不能被重写
  • 修饰成员变量：表示变量不能被改变
//探究关键词final
public class Test {
    public static void main(String[] args) {
    }
}

class A {      //final修饰的类不能被继承
//    public final void f1(){};  //final修饰的方法不能被重写
    public void f1() {
    }
}

class B extends A {
    public final int i = 1;
    @Override
    public void f1() {
//        i = 20;      //final修饰的属性不能被改变
    }
}

5. 抽象类

  1. 用abstract关键字来修饰一个类，这个类叫做抽象类。
  2. 用abstract来修饰一个方法，该方法叫做抽象方法。抽象方法：只有方法的声明，没有方法的实现。如public abstratc void talk();注意没有大括号
  3. 含有抽象方法的类必须声明为抽象类
  4. 抽象类不能被实例化，只能用来继承，子类重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类
//探究抽象类的特性
public abstract class A {//声明抽象类
    public abstract void f1();//抽象方法
    public void f2() {//抽象类中可以写非抽象的方法
        System.out.println("这是一个f2()方法。。。");
    }
}
public class B extends A {
    @Override
    public void f1(){//实现抽象类中的抽象方法
        System.out.println("实现抽象类的f1()方法。。。");
    }
}
//测试
public class Test {
    public static void main(String[] args) {
//        new A();//不能实例化抽象类
        B b = new B();//实例化抽象类的子类实现父类的抽象方法
    }
}

6. 接口

  • 有了接口， 就可以得到多重继承的效果。
  • 它们之间又没有is-a的关系，但是具有相同的行为特征。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、 MP3机、手机、数码相机、移动硬盘等都支持USB连接。
  • 继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
public interface Usb {
    //接口方法默认有public abstract
    public void start();
    public void end();
    //接口中不能有非抽象方法，只能存在抽象方法
//    public void f1(){};  报错
}
public interface TypeC {
    void transfer();
}
public class Printer implements Usb, TypeC {//接口能实现多继承，抽象类不能
    @Override
    public void transfer() {
        System.out.println("TypeC接口传输数据");
    }
    @Override
    public void start() {
        System.out.println("Usb接口启动");
    }
    @Override
    public void end() {
        System.out.println("Usb接口关闭");
    }
}

6.1 接口与抽象类

  • 抽象类可以有非抽象方法，接口只能有抽象方法
  • 接口中方法默认带public abstract
  • 接口可以实现多继承,抽象类不可以

7. 内部类(了解)

将一个类放在另一个类的内部，这个类就叫做内部类
内部类的分类：

  • 在成员变量的位置
    • static成员内部类
    • 非静态的成员内部类
  • 在方法中的某个位置：局部内部类

语法：

  • 修饰成员变量的所有的修饰符都可以修饰成员内部类
  • 部类可以使用继承
//探究内部类的使用
public class Test {
    public static void main(String[] args) {
        //创建静态属性内部类的方法
        Person.Dog dog = new Person.Dog();
        dog.eat();
        //创建非静态属性内部类的方法
        Person p = new Person();
        Person.Cat cat = p.new Cat();
        cat.eat();
        //成员方法中定义的局部内部类
        p.f1();
    }
}
public class Person {
    private String name;
    private int age;

    //内部类，如果一个类只给当前的类使用，其他的类无法使用，比如Dog 和Cat类只能在Person中使用
    //静态内部类
    public static class Dog {
        public void eat() {
            System.out.println("狗吃骨头");
        }
    }
    public class Cat {//内部类
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    public void f1() {//局部内部类
        class Bird {
            public void eat() {
                System.out.println("鸟吃虫子");
            }
        }
        Bird bird = new Bird();
        bird.eat();
    }
}

8. 匿名内部类

  • 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
  • 匿名内部类的特点
    • 匿名内部类必须继承父类或实现接口
    • 匿名内部类只能有一个对象
    • 匿名内部类对象只能在使用多态形式引用
语法：
接口 变量名 =  new 接口 {
	重写的代码
}

案例如下：

package test8;//探究匿名内部类的使用和原则

public class Test {
    public static void f1(Usb usb) {
        usb.start();
        usb.end();
    }
    public static void f2(TypeC typeC) {
        typeC.transfer();
    }
    public static void main(String[] args) {
        //方法1：
        /*
        1.多态性：编译类型时父类
        2.new接口，后面跟一个实现
        3.有一个对象usb1，实现了Usb接口的一个没有名字的类的实例
         */
        Usb usb1 = new Usb() {
            @Override
            public void start() {
                System.out.println("打印机Usb启动");
            }
            @Override
            public void end() {
                System.out.println("打印机Usb关闭");
            }
        };
        f1(usb1);
        //方法2：匿名内部类直接作为方法的参数
        f2(new TypeC() {
            @Override
            public void transfer() {
                System.out.println("苹果14正在传输数据...");
            }
        });
    }
}
public interface TypeC {
    void transfer();
}
public interface Usb {
    //接口方法默认有public abstract
    public void start();
    public void end();
    //接口中不能有非抽象方法，只能存在抽象方法
//    public void f1(){};  报错
}
ANONYMOUS%
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
static—final—单例模式—final
qq_49143649的博客
07-17 718
static静态的含义 （一）修饰成员变量，方法，匿名块，内部类静态变量，静态方法，静态块，静态内部类 （二）特点：被静态修饰的成员，属于类，会被所有的对象所共享被静态修饰的成员，可以直接通过“类名”直接访问类名.静态属性名类名.静态方法名(参数值); （三）注意事项静态的成分，优先于对象存在，随着类的加载完成分配在静态方法中，不能使用 this 和 super 关键字，不能直接访问非静态成分在静态方法中，只能直接访问静态属性和静态的方法，若想要访问非静态的，则必须先创建对象静态块：属于类，在类加载的时候最
java单例接口_JAVA单例模式
weixin_29876341的博客
02-13 837
一.问题引入偶然想想到的如果把Java的构造方法弄成private，那里面的成员属性是不是只有通过static来访问呢；如果构造方法是private的话，那么有什么好处呢；如果构造方法是private的话，会不更好的封装该内呢？我主要是应用在使用普通类模拟枚举类型里，后来发现这就是传说中的单例模式。构造函数弄成private 就是单例模式，即不想让别人用new 方法来创建多个对象，可以在类里面先生...
Java-单例实现接口
qq_41607217的博客
04-19 952
Java-单例实现接口 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。当接口只用一次时，划不来创建一个类对他进行实现，可以用内部类直接实现 package Implement; interface CompurerAverage { publ
java 的 static 和 final 用法和单例模式
晓丶峰
07-04 611
static： 变量： 生命开始：类加载的时候被初始化，只执行一次 存放地：方法区内存 变量：类名.静态变量名 对象.静态变量名（不推荐的方式） 可多次更改： 代码块： 生命开始：类加载的时候被执行，只执行一次 存放地：方法区内存
java 单例接口,在实现接口的类上强制单例模式
weixin_27427619的博客
02-16 205
I better explain the question with an example.I have an Interface Model which can be used to access data.There can be different implementations of Model which can represent the data in various format ...
Java 学习 day14： 匿名内部类,单例模式(饿汉,懒汉),工厂模式
whosedad的博客
10-17 740
1.匿名内部类 1.1 2.单例模式 2.1 3.工厂模式 3.1
十分钟学会 java中的单例模式,匿名内部类, Lanbda表达式的使用以及异常的处理
weixin_45768979的博客
11-29 812
单例模式 单例模式是23种设计模式中的一种,这里简单介绍一下单例模式 什么是单例模式? **单例模式:**单例模式是为了保证JVM中某一个类型的java对象永远只有一个. **目的:**为了节省内存的开销 实现步骤: 构造方法私有化 对外提供一个公共的静态的获取当前类型对象的方法 提供一个当前类型的静态变量 单例模式分为两种: 饿汉式单例:在类加载阶段就创建了对象 懒汉式单例:用到对象的时候...
抽象类abstract、接口interface、静态static、final，单例模式，常量解读——JAVA
weixin_43698704的博客
01-15 625
目录 一、抽象类和接口 二、static、final，单例模式，常量 2.1static 2.2单例模式： 2.3final 2.4常量 三、private\default\protected\public 一、抽象类和接口 抽象类：一个类暂时由方法未实现，需要被定义未抽象类。 类的继承：一个类仅仅只能继承一个类，抽象类也可以被其他类唯一继承。继承抽象类的类必须实现抽象类...
Java23种设计模式--单例模式：饿汉式单例&懒汉式单例&注册式单例&ThreadLocal线程单例
OASISHzzggg的博客
02-21 618
Java23种设计模式--单例模式：饿汉式单例&懒汉式单例&注册式单例&ThreadLocal线程单例
java接口和类（八）创建单例类
xiaotian15的专栏
04-24 342
单例类的创建：     class count {     private static final count c=new count();     private count()   //构造方法必须是私有的；不可以省略；     {             }     public static count getCount()//static说明该方法属于类，
javase第十讲关于接口、单例模式
新白的博客
03-24 345
关于接口、单例模式
【第11天】Java的单例模式、接口以及Object类常用的方法
來秋的技術之路
11-19 881
第十一天，学习了单例模式、接口以及Object类常用的五个方法。
单例模式
qq_1240545777的博客
07-03 185
关于单例模式中的final关键字：懒汉式中一开始声明的类的实例化对象为什么只用private static 声明了而没有加final关键字？声明final的变量，必须在类加载完成时已经赋值，如果你是final非static成员，必须在构造器、代码块、或者直接定义赋值；如果是fainal static 成员变量，必须直接复制或者在静态代码块中赋值static {//静态代码块        inst...
面试必考-static、final和单例模式
qq_36523667的博客
01-09 4129
static 那天我朋友问了我个问题，static和单例模式有什么区别，所以我觉得static可以讲一下 他的问题是，把对象弄成static是不是就不变了 显然，这是还没弄清楚引用和对象的区别 其实存放在静态区中的是引用，而不是对象。而对象是存放在堆中的。如果有这样一句话 public static final Book book = new Book(); 意思就是b
java中的接口知识（单例模式、静态代理、工厂模式）！
qm_qzm的博客
06-02 415
接的定义 接口是特殊的抽象类 接口的优点：定义开发规范 提高代码的复用性 解耦 多实现类只能单继承 在jdk1.7及之前接口中只能存在公共的静态的常量+公共的抽象方法 公共的静态的常量: public static final 数据类型 变量名=赋值; 修饰符可以省略,默认存在 公共的抽象的方法: public abstract 返回值类型 方法名...
接口实现单例模式
u014582551的博客
06-19 1919
<?php//定义接口interface Calc{ public function getValue($num1,$num2);}//创建实现接口的实体类class Add implements Calc{ public function getValue($num1,$num2) { return $num1 + $num2; }}class Sub implements Calc{ ...
static实现单例的隐患
yi_Afly的专栏
07-29 2008
1. 前言Java的单例有多种实现方式：单线程下的简单版本、无法在指令重排序下正常工作的Double-Check、static、内部类+static、枚举……。这篇文章要讨论的，是在使用static实现饿汉模式的单例时，会有隐患存在。2. Static单例的隐患2.1 传统写法static实现单例的代码如下：public class Singleton { private static Si
java static 单例_实现单例模式的两种方法（static final对象、getInstance）
weixin_39541767的博客
02-24 286
[java]代码库//使用第一种方式的单例模式类，通过公共属性来创建对象public class SingletonDemo2 {//第一种实现单例模式的方法，通过公共属性来实现实例化//声明一个公共的静态属性，使只被实例化一次public static final SingletonDemo2 singletonDemo = new SingletonDemo2();//声明一个私有的构造方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值