📄个人简介
🔔作者简介：大家好，我是小学生！！🙈大二学生一枚，目前正在自学Java，如果大家觉得我写的还不错的话，希望大家给我点赞👍+收藏⭐+评论📢，有什么写的不对的地方还请大家多多指教🙏，共同进步。
📝个人主页：小学生！！
📖系列专栏
🌕阶段一：Java基础编程
💦目前已原创14篇

🌕阶段二：数据结构与算法
🌕阶段三：操作系统
🌕阶段四：计算机网络

🔥本文主要讲了单例模式中的饿汉式和懒汉式的区别，final的使用，抽象类的介绍以及接口的具体内容。

文章目录

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

1.单例模式

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

步骤：

1. 将构造器私有化

2. 类的内部创建对象

3. 向外暴露一个静态的公共方法

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.懒汉式和饿汉式的区别

1. 创建对象的时机不同：饿汉式在类加载是就创建了对象，懒汉式是在使用时再创建。

2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。

3. 饿汉式在类加载是就创建了对象所以存在资源浪费的问题，但懒汉式就不存在这个问题。

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() {     }} 

创作打卡挑战赛 赢取流量/现金/CSDN周边激励大奖