疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

JavaSE基础static、final、abstract


 

   

  1.static关键字

  1.static:静态的,可用来修饰属性,方法,代码块,内部类

  2.static修饰属性(类变量):

  ①由类创建的所有的对象,都共用这一个属性

  ②当其中一个对象对此属性进行修改,会导致其他对象对此属性的一个调用。vs实例变量(非static修饰的属性,各个对象各自拥有一套副本)

  ③类变量随着类的加载而加载。而且独一份

  ④静态的变量可以直接通过“类.类变量”的形式来调用

  ⑤类变量的加载是要早于对象,所以当有对象以后,可以“对象.类变量”使用。但是“类.实例变量”是不行的

  ⑥类变量存在于静态域中

  static修饰方法(类方法):

  ①随着类的加载而加载,在内存中也是独一份

  ②可以直接通过“类.类方法”的方式调用

  ③内部可以调用静态的属性或静态的方法,而不能调用非静态的属性或方法,反之,非静态的方法是可以调用静态的属性或静态的方法

  >静态的方法内是不可以有this或super关键字的

  注:静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构,同时被收回也晚于非静态的结构

  单例模式:

  23种设计模式

  单例模式:

  解决的问题:如何只让设计的类只能创建一个对象

  如何实现:饿汉式&懒汉式

  //饿汉式1

  class Bank{

  //1.私有化构造器

  private Bank(){}

  //2.创建类的对象,同时设置为private的,通过公共的方法来调用,体现封装性

  //4.要求此对象也为static的

  private static Bank instance = new Bank();

  //3.此公共的方法,必须为static

  public static Bank getInstance(){

  return instance;

  }

  }

  //饿汉式2

  class Bank{

  //1.私有化构造器

  private Bank(){}

  //2.创建类的对象,同时设置为private的,通过公共的赖调用,体现封装性

  //4.要求此对象也为static的

  private static Bank instance =null;

  static{

  instance = new Bank();

  }

  //3.此公共的方法,必须为static

  public static Bank getInstance(){

  return instance;

  }

  }

  //懒汉式

  class Bank{

  private Bank(){}

  private static Bank instance = null;

  public static Bank getInstance(){

  if(instance == null){//可能存在线程安全问题

  instance = new Bank();

  }

  return instance;

  }

  }

  2.main()方法:

  public static void main(String[] args){

  //方法体

  }

  1.main()是一个方法,主方法,为程序的入口

  2.public :权限修饰符 protected 缺省 private 面向对象的封装性

  3.static :对于方法来讲 ,修饰符 static final abstract

  4.void 方法的返回值:void/具体的返回值类型(基本&引用),方法内部一定要有return

  5.方法名:命名规则:xxxYyyZzz,给方法命名时,见名知意

  6.形参列表:同一方法名不同的形参列表的诸多个方法构成重载 。形参&实参---方法的参数传递机制:值传递

  7.方法体:方法定义的是一种功能,具体的实现由方法体操作。

  3.代码块

  代码块/初始化快:类的第四个成员

  作用:用来初始化类的属性

  分类:只能用static修饰

  静态代码块&非静态代码块

  静态代码块:

  1)里面可以有输出语句

  2)随着类的加载而加载,而且只被加载一次

  3)多个静态代码块之间按照顺序结构执行

  4)静态代码块的执行要早于非静态代码块的执行

  5)静态代码块只能执行静态的结构(类属性、类方法)

  非静态代码块:

  1)可以对类的属性(静态的&非静态的)进行初始化操作,同时也可以调用本类声明的方法(静态的&非静态的)

  2)里面可以有输出语句

  3)一个类中可以有多个非静态的代码块,多个代码块之间按照顺序结构执行

  4)每创建一个类的对象,非静态代码块就加载一次

  5)非静态代码块的执行要早于构造器

  属性赋值:①默认的初始化②显式的初始化或代码块初始化(此处两个结构按照顺序执行)③构造器中④通过方法对对象的相应属性进行修改

  ①②③是对象属性初始化的过程

  4.final关键字:

  final:最终的 用来修饰类、属性、方法

  1.final修饰类:这个类就不能被继承。如:String类、StringBuffer类、System类

  2.final修饰属性:此属性就是一个常量,一旦初始化后,不可再被赋值。习惯上,常量用大写字符表示。

  此常量在哪里赋值:①此常量不能使用默认初始化②可以显式的赋值、代码块、构造器

  3.final修饰方法:不能被重写。如:Object类的getClass()

  常量用static final修饰:全局常量 比如Math类的PI

  5.抽象类abstract:

  abstract:抽象的,可以用来修饰类、方法

  1.abstract修饰类:抽象类

  1)不可被实例化

  2)抽象类有构造器(凡是类都有构造器)

  3)抽象方法所在的类,一定是抽象类

  4)抽象类中可以没有抽象方法

  >当我们设计一个类,不需要创建此类的实例的时候,就可以考虑将其设置为抽象的,由子类实现这个类的抽象方法以后,进行实例化

  2.abstract修饰方法:抽象方法

  1)格式:没有方法体,包括{}。如:public abstract void eat();

  2)抽象方法只保留方法的功能,而具体的执行,交给继承抽象类的子类,由子类重写此抽象方法

  3)若子类继承抽象类,并重写了所有的抽象方法,则此类是一个“实体类”,可以实例化

  4)若子类继承抽象类,没有重写所有的抽象方法,意味着此类中仍有抽象方法,则此类必须声明为抽象的

  当设计一个类 不需要此类的实例 考虑设置为抽象的 由其子类实现其抽象方法

  模板方法设计模式(TemplateMethod)

  抽象类体现的就是一种模板模式的设计,抽象类作为多个子类通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。

  解决的问题:

  1.当功能内部一部分实现是确定,一部分实现是不确定的,这时可以吧不确定的部分暴露出去,让子类去实现。

  2.编写一个抽象父类,父类提供了多个子类的通用方法,并把一个或多个方法留给其子类实现,就是一种模板模式。

  例子:

  //模板方法设计模式

  public class TestTemplate {

  public static void main(String[] args) {

  new SubTemplate().spengTime();

  }

  }

  abstract class Template{

  abstract void code();

  public void spengTime(){

  long start = System.currentTimeMillis();

  code();

  long end = System.currentTimeMillis();

  System.out.println("花费的时间为: " + (end - start));

  }

  }

  class SubTemplate extends Template{

  public void code(){

  boolean flag = false;

  for(int i = 2;i <= 10000;i++){

  for(int j = 2;j <= Math.sqrt(i);j++){

  if(i % j == 0){

  flag = true;

  break;

  }

  }

  if(!flag){

  System.out.println(i);

  }

  flag = false;

  }

  }

  }