java抽象类可以用final,final类实例化

　　00-1010 1.单一模式1。饥饿中国式和懒惰中国式的实现2。饥饿-中国式3。懒——中国式4。懒中式和饿中式的区别2。2.final 1的使用。基本介绍2。使用场景3。笔记和细节讨论3。抽象类1。基本介绍2。注释和细节讨论4。接口1。基本介绍2。注释和细节讨论

目录

　　00-1010步：

　　向静态公共方法公开构造函数私有化类的内部创建的对象。

　　00-1010 class school 1 {//饿中文私有字符串名；//直接在类内部创建对象Private Static school 1sc=New school 1(清华大学)；//私有化构造函数private school 1(string name){ this . name=name；}//提供公共静态方法返回对象公共静态school getinstance(){ returnsc；}}

　　00-1010 class school 2 {//懒惰私有字符串名；//直接在类内部创建对象private static School2 sc//私有化构造函数private school 2(string name){ this . name=name；}//提供一个公共静态方法来返回对象。//如果对象为空，则创建对象；否则直接返回对象publicstaticschool 2 getinstance(){ if(sc==null){ sc=new school 2(清华大学)；}返回sc；}}

　　00-1010创建对象的时机不同：饿汉在类加载时创建对象，懒汉在使用时创建。中国式没有线程安全问题，懒式有线程安全问题。类内饥饿加载会创建对象，所以存在资源浪费，而懒加载没有这个问题。

1.单例模式

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

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

　　00-1010 不想继承父类时。

　　当你不希望父类的方法被子类覆盖时。

　　当您不想修改类的属性时

　　当您不想修改局部变量时

　　最终A类{ }；//当不想继承父类时。B类{公开最终void显示(){ }；//不希望父类的方法被子类重写时。public final int A _ B=10//当不希望类的某个属性被修改时，public void show(){ final int a _ c=20；//当您不想修改局部变量时}}

　　00-1010 1.final修改的属性也叫常量，一般是XX_XX。

　　2.定义2.final修饰属性时，必须在以下位置分配初始值

　　定义时直接赋值。

　　在构造函数中赋值。

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

　　类{//在定义时直接赋值。public final int a=10//{//a=10；//在代码块中赋值。//}////public A(){//A=10；//在构造函数中赋值。//}}3.如果final修饰的属性是静态的，则初始化的位置只能是

　　定义时直接赋值。

　　在静态代码块中赋值。

　　类{//在定义时直接赋值。public final静态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单例模式内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。