Java Study For Six Day( 面向对象二)

static(静态)关键字

　　用于修饰成员(成员变量和成员函数)

　　被修饰后的成员具备以下的特点

　　　　随着类的加载而加载

　　　　优先于对象存在

　　　　被所有的对象共享

　　　　可以被类名直接调用

　　静态注意事项

　　　　静态方法只能访问静态成员(原因:因为静态的内容是随着类的加载而加载，它先进内存)

　　　　静态方法中不能使用this、super关键字

　　　　主函数是静态的　

　　　　　public static void main(String[] args)

   　　　　public:公共的意思，是最大权限修饰符。

   　　　　static:由于jvm调用main方法的时候，没有创建对象。

          　 只能通过类名调用。所以，main必须用static修饰。

   　　　　void:由于main方法是被jvm调用，不需要返回值。用void修饰。

   　　　　main:main是主要的意思，所以jvm采用了这个名字。是程序的入口。

　　　　　 String[]:字符串数组

  　　　　  args:数组名

　　　　 在运行的时候，通过java命令给args数组赋值。

   　　　　 格式：java MainTest hello world itcast

　　静态变量和成员变量的区别

　　　 1.调用方式

　　　　　　静态变量也称为类变量，可以直接通过类名调用，也可以通过对象调用，这个变量属于类

　　　　　　成员变量也称为实例变量，只能通过对象名调用，这个变量属于对象

　　　　2.存储位置

　　　　　　静态变量存储在方法区中的静态区而成员变量存储在堆内存中

　　　　3.生命周期

　　　　　　静态变量随着类的加载而存在，随着类的消失而消失，周期较长

　　　　　　成员变量随着对象的创建而存在，随着对象的消失而消失

　　　　4.与对象的相关性

　　　　　　静态变量是所有对象共享的数据而成员变量是每个对象所特有的数据

静态的优点和弊端

　　优点:对对象的共享的数据进行单独的空间存储，节省内存，可以直接用类名调用

　　弊端:生命周期较长，随着类的消失才消失，访问权限出现限制，既静态只能访问静态，访问非静态需要使用对象

为什么使用静态？

　　A:当所有对象共享某个数据的时候，就把这个成员变量定义为静态修饰的。

　　B:当某个方法没有访问该类中的非静态成员，就可以把这个方法定义为静态修饰。

　　但是因为静态的生命周期较长，所以一般不推荐使用

静态代码块

　　它只执行一次，比main还先执行

　　执行的顺序:静态代码块--->构造代码块--->构造函数

　　class Person

　　{

 　　　　String name;//成员变量，实例变量。（对象在该实例才在）

 　　　　static String country = "cn";//静态的成员变量，类变量

　　 　　public void show()

 　　　　{

  　　　　　　System.out.println(name+"::::"+country);

 　　　　}

　　}

　　class StaticDemo

　　{

 　　　　public static void main(String[] args)

 　　　　{

 　　 　　　　//Person p = new Person();

 　　　　 　　//p.name = "zhangsan";

  　　　　　　//p.show();

  　　　　　　System.out.println(Person.country);

 　　　　}

　　}

*主函数

class MainDemo

{

 　　public static void main(String[] args)//new String[]

 　　{

  　　　　System.out.println(args.length);

 　　}

}

　　//String[] args = new String[3];

　　//String [] args = null;

class Person

{

 　　String name;

　　public static void show()

 　　{

  　　　　System.out.println("haha"); 

 　　}

}

class StaticDemo1

{

 　　public static void main(String[] args)

 　　{

  　　　　//Perosn p = new Person();

  　　　　//p.show();

  　　　　Person.show();

 　　}

}

*静态的应用

public class ArrayTool

{

 　　private ArrayTool(){};//构造函数私有化：为了更为严谨，强制让该类不能建立对象。

 　　public static int getMax(int[] arr)

 　　{

  　　　　int max = 0;

   　　　　for(int x = 1;x<arr.length;x++)

  　　　　{

   　　　　　　if(arr[x]>arr[max])

    　　　　　　max = x;

   　　　　}

   　　　　　　return arr[max];

 　　}

  　　public static int getMin(int[] arr)

  　　{

   　　　　int min =0;

  　　　　for (int x = 1;x<arr.length ;x++ )

  　　　　{

   　　　　　　if(arr[x]<arr[min])

    　　　　　　min = x;

  　　　　}

 　　　　　　return arr[min];

 　　}

 　　public static void selectSort(int [] arr)

 　　{

  　　　　for (int x = 0;x<arr.length-1 ;x++ )

  　　　　{

   　　　　　　for (int y =x+1;y<arr.length ;y++ )

   　　　　　　{

    　　　　　　　　if(arr[x]>arr[y])

    　　　　　　　　{

     　　　　　　　　　　swap(arr,x,y);

    　　　　　　　　}

   　　　　　　} 

  　　　　}

 　　　}

 

 　　public static void bubbleSort(int[] arr)

 　　{

  　　　　for (int x = 0;x<arr.length-1 ;x++ )

  　　　　{

   　　　　　　for (int y=0;y<arr.length-1-x ;y++ )

   　　　　　　{

    　　　　　　　　if(arr[y]>arr[y+1])

    　　　　　　　　{

     　　　　　　　　　　swap(arr,y,y+1);

    　　　　　　　　}

   　　　　　　}

  　　　　}

 　　}

 

 

 private static void swap(int[] arr,int a,int b)//把不需要其他类使用的功能私有化。

 {

  　　int temp = arr[a];

  　　arr[a] =arr[b];

  　　arr[b] =temp;

 }

 public static void printArray(int[] arr)

 {

  　　System.out.print("[");

 　　 for (int x=0;x<arr.length ;x++ )

  　　{

   　　　　if(x!=arr.length-1)

    　　　　　　System.out.print(arr[x]+",");

   　　　　else

    　　　　　　System.out.println(arr[x]+"]");

  　　}

 }

}

　　一个类总会默认会有一个空参数的构造函数。

　　这个默认的构造函数的权限和所属类一致

　　如果类被public修饰，那么默认的构造函数也被public修饰。

　　如果类没有被public修饰，那么默认的构造函数，也没有public修饰

　　默认构造函数的权限是随着类的变化而变化

如何制作(API)

　　全称:Application  Program Interface 应用程序接口

　　类中的内容需要用文档注释

　　使用JDK\bin目录下的javadoc工具

　　　　格式:javadoc -d 目录 -author -version Arraytools.java

单例设计模式

　　设计模式:解决某类问题行之有效的方法，是一种思想，是规律的总结

　　用来保证某个类在内存中只有一个对象

　　保证唯一性的思想及步骤

　　　　为了避免其它程序建立该类的对象，先禁止其它程序建立该类的对象，即将构造函数私有化

　　　　为了其它程序能访问到该类对象，从而在本类中需要创建一个私有的对象

　　　　为了方便其它程序能访问到该类对象，因而需要对外提供一个公共的访问方式　　

　　　　例如:javaAPI中的Runtime类就是一个典型的单例设计模式

单例设计模式的两种方式

  　　A:饿汉式 当类加载的时候，就创建对象。 

  　　class Student

  　　{

  　　　　 private Student(){}

   

   　　　　private static final Student s = new Student();

   

   　　　　public static Student getInstance()

   　　　　{

    　　　　　　return s;

   　　　　}

 　　  }

  　　B:懒汉式 当使用的使用，才去创建对象。

  　　　　class Student

  　　　　{

   　　　　　　private Student(){}

　　　　　　private static final Student s = null;

   

   　　　　　　public static Student getInstance()

   　　　　　　{

    　　　　　　　　if(s==null) 

    　　　　　　　　{

     　　　　　　　　　　//线程1就进来了，线程2就进来了。

     　　　　　　　　　　s = new Student();

    　　　　　　　　 }

    　　　　　　　　　　return s;

   　　　　　　}

  　　　　}

 　　饿汉式和懒汉式的区别：

  　　　　饿汉式是类一加载进内存就创建好了对象；

  　　　　懒汉式则是类才加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，

  　　对象才开始创建。

  　　　　懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题

  　　　　可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，

  　　　　所以可以加双重判断来提高程序效率。

  　　　　注：开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题

附加:

Math类的使用

　　数学操作类:给类都是静态的，没有构造方法

　　掌握的知识

　　　　成员变量

　　　　　　E:比任何其它值都更接近e（即自然对数的底数）的double值

　　　　　　PI:比其它任何值更接近PI(即圆的周长与直径之比)的double值

　　　　成员方法

　　　　　　static double abs(double a)返回double值的绝对值 返回绝对值

　　　　　　static double ceil(double a) 返回最小值的double值，该值大于或是等于参数，并等于某个整数

　　　　　　static double floor(double a)返回最大值double值，该值小于或是等于参数，并等于某个整数

　　　　　　max:返回两个值的较大的那个

　　　　　　min:返回两个值的较小的那个

　　　　　　static long round(double a)返回最接近参数的long

　　　　　　static int round(float a)返回最接近参数的int

　　　　　　static double random()返回带正号的double值，该值大于或是等于0.0且小于1.0

　　　　　　static double pow(double a，double b)返回第一个参数的第二个参数次幂的值

　　　　　　static double sqrt(double a)返回正确的舍入的double值的平方根