1.单例模式
1.饿汉式和懒汉式的实现
步骤：
将构造器私有化 类的内部创建对象 向外暴露一个静态的公共方法
2.饿汉式
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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.懒汉式
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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.使用场景
①当不希望父类被继承。
②当不希望父类的方法被子类重写。
③当不希望类的某个属性被修改
④当不希望某个局部变量被修改
|
1 2 3 4 5 6 7 8 |
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修饰的属性定义时，必须在以下位置赋初值
①定义时直接赋值。
②在构造器中赋值。
③在代码块中赋值。(普通属性在普通代码块初始化，静态属性在静态代码块初始化)
|
1 2 3 4 5 6 7 8 9 10 11 |
class A { // 定义时直接赋值。 public final int a = 10 ; // { // a = 10;//在代码块中赋值。 // } // // public A() { // a = 10;//在构造器中赋值。 // } } |
3.如果final修饰的属性是static，则初始化的为位置只能是
①定义时直接赋值。
②在静态代码块中赋值。
|
1 2 3 4 5 6 7 8 9 10 11 |
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还可以用来修饰一个方法，即抽象类。
|
1 2 3 4 |
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 接口{
自己属性;
自己方法;
必须实现的接口的抽象方法；
}
|
1 2 3 4 5 6 7 8 9 10 11 |
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.当一个类实现了一个接口，这个类就可以调用接口中的所有属性和默认方法，但不能调用接口中的静态方法。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
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.接口与继承同时出现如何访问属性
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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.多态参数
接口可以接受不同的对象，接口的引用也可以指向实现了接口的类的对象。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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.多态数组
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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( "相机正在工作。。。" ); } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
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.接口存在多态传递现象
|
1 2 3 4 5 6 7 8 9 10 |
interface AA{ void display(); } interface BB extends AA{ } class CC implements BB{ @Override public void display() { } } |
到此这篇关于Java零基础也看得懂的单例模式与final及抽象类和接口详解的文章就介绍到这了,更多相关Java单例模式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
原文链接：https://blog.csdn.net/m0_54024106/article/details/124640714
查看更多关于Java零基础也看得懂的单例模式与final及抽象类和接口详解的详细内容...