java 单例类 final类 抽象类

单例设计模式：解决一个类在内存中只存在一个对象.

想要保证对象的唯一：

1 禁止其他程序自由创建对象：将构造方法私有化，使用private修饰。

2为了让其他程序可以访问到该类对象,只能在本类定义一个对象:在类中创建一个本类对象

3 为了让其他程序可以对该对象的访问,提供一个public方法可以获取该对象.

一个类始终只能创建一个实例，则这个类被称为单例类。

1饿汉式：不管用不用，一开始就创建对象,即先初始化对象.\

开发一般使用此写法,安全性

Privatestatic String s=new Single（）；

PrivateSingle（）{}

Publicstatic Single getIntance（）{

Returns；

}

 

2懒汉式：使用时才建立对象，是延迟加载。

privatestatic Single1 s=null;

      private Single1(){}

          public static Single1 getInstance(){

                if(s==null){

                            s=new Single1();

                         }

                     return s;

           }

final修饰符

final关键字可用于修饰类，变量和方法，用于表示他修饰的类，变量和方法不可改变。

final 变量

final修饰变量时，表示该变量一旦获得了初始值之后就不可被改变，final既可修饰成员变量（包括类变量和实例变量），也可以修饰局部变量，形参。

final修饰成员变量

         成员变量：1 类变量：当类初始化时，系统会为类变量分配内存，并附默认值。

                   2实例变量：当创建对象时，系统会为该对象的实例属性分配内存，并附默认值

Final修饰的类变量，实例变量能指定初始值的地方

A 类变量：静态变量初始化或声明该属性时指定初始值

B实例变量：非静态初始化块，声明该属性或构造方法中指定初始值。

注意：实例属性不能再静态初始化中指定初始值，因为静态初始化块是静态成员，不可访问实例属性----非静态成员；类属性在类初始化阶段已经被初始化，普通初始块不能对其重新赋值。

final成员的使用示例

public class Test{

         finalint age；{

         System.out.println（age）；

}

Public static void main（String[]args）{

                   newTest();

}

}

final 修饰局部变量：

a可以再定义时指定默认值，则后面代码中不能再对该变量赋值。

B如果在定义时没有指定默认值，则只能一次，不能重复赋值。

Final修饰基本类型和引用类型的区别

Eg

class Person{

private int age;

public Person(){}

public Person(int age){

this.age = age;

}

Public void setAge(intage){

This.age = age;

}

Public int getAge(){

return this.age;

}

}

Public class T    estFinalReference{

Public static voidmain(Styring[] args){

Final Person p = newPerson(45);

         p.setAge(23);

         Syetem.out.println(p.setAge());

}

}

         1当用final修饰基本数据类型时，不能对基本数据类型变量重新赋值，即基本数据类型变量不能被改变。

2引用类型变量保存的是一个引用，final值保证这个引用（地址）不会改变，即一直引用同一个对象，但这个对象可以发生改变。

Final方法

Final修饰的方法不可被重写，如果出于某些原因，不希望子类重写父类的某个方法，则可以使用final修饰该方法。

Final 修饰的方法仅仅是不能被重写，并不是不能重载。

Final修饰的类子类。Eg   java.lang.Math类就是一个final类，它不可以有子类。

抽象类

Java中，没有方法体的方法 

注意：a含有抽象方法的类（包括直接定义了一个抽象方法；继承了一个抽象父类）                                                             

抽象类

Java中，没有方法体的方法称为抽象方法。丑行类的声明

µ  [修饰符] abstract  返回值类型方法名([形式参数表]);

µ  抽象方法的特点

ü  抽象方法的返回值类型前有关键字abstract；

ü  抽象方法没有方法体；

ü  抽象方法的定义是一行单独语句，以分号结束；

ü  在抽象方法声明中使用static修饰符是错误的。

例如，public abstract double area();

¯    抽象类

      类中如果定义了抽象方法，这个类必须定义为抽象类。

      [public]  abstract class 类名{

            //类体（属性、非抽象方法、抽象方法、构造方法）

            //类体（初始化块、内部类、枚举类）  

      }

µ  抽象类不能创建自己的对象，使用new创建抽象类对象将产生错误。

µ  子类继承抽象类时，应该覆盖抽象类中的所有抽象方法，否则子类也必须定义为抽象类。

µ  注意

µ  含有抽象方法的类（包括直接定义了一个抽象方法；继承了一个抽象父类，但没有完全实现父类包含的抽象方法）只能被定义成抽象类。但抽象类中却并一定包含抽象方法。

µ  抽象方法和空方法体的方法不是同一个概念
public abstract void test();
public void test(){}

µ  一个普通方法，定义了方法体，只是方法体为空，因此这个方法不可以使用abstract来修饰

µ  例5.18 抽象类示例。

µ  publicabstract class Shape{

µ        public abstract double calcArea();

µ        public Shape(){}

µ        public Shape(String name){

µ    System.out.println(name+ " ShapeCreated");

µ        }

µ        public String toString(){

µ    System.out.println(“this is Shape!”);

µ        }

µ  }

µ  publicclass Circle extends Shape{

µ        public float r;

µ        private final float PI=3.14;

µ        public Circle(String name,float r){

µ          super(name);

µ          this.r=r;

µ        }

µ        public float calcArea(){

µ          return PI*r*r;

µ        }

µ  }

注意

ü  final和abstract永远不能同时使用。

ü  abstract不能用于修饰属性，不能用于修饰局部变量，即没有抽象变量、没有抽象属性等说法；abstract也不能用于修饰构造方法，没有抽象构造方法。抽象类里定义的构造方法只能是普通构造方法。

ü  static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法。

ü  abstract关键字修饰的方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，因此abstract方法不能定义为private访问权限。

ü  抽象类的作用

ü  代码重用－－子类可以重用抽象父类中的属性和非抽象方法；

ü  规划－－抽象类中通过定义抽象方法规划了其所有子类必须要实现的功能，或者说指定了其子类对象与外界的交互界面，因为抽象方法的方法头部分已经规定了该方法将来被子类对象调用的格式。

ü  模板模式：抽象类作为多个子类的通用模板，子类在抽象类的基础上扩展、改造，但子类总体上会保留抽象类的行为方式。

ü  抽象类不能实例化，但抽象类可作为变量的类型和方法形参类型，可将抽象类子类的对象赋给该变量或做方法的实参。例如，
Shape s=new Rectangle();
public static String ShowShapinfo(Shape item){
      if(item instanceof Rectangle){
                    Rectangle r=(Rectangle)item;//其他代码
      }
}