亲宝软件园·资讯

展开

Java单例模式

小学生!! 人气:0

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

加载全部内容

相关教程
猜你喜欢
用户评论