java学习

今天学习了面向对象的静态方法，接下来与大家分享干货。

访问的方式

可以使用“类名.静态属性名”或者“对象名.静态属性名”的方式进行访问。【范围限制】
定义常量
命名规则：名称全大写，下划线分词
声明语法：public static Õnal double MIN_NUMBER = 0.1;
声明的同时直接进行初始化
public static Õnal double MIN_NUMBER = 0.1;
先声明后在static静态块中赋值

public static final double MIN_NUMBER;
 static{
  MIN_NUMBER = 0.1; 
  }

静态方法

因为可以直接使用”类名.方法名”的形式直接调用静态方法，静态方法执行时很有可能并没有构建对象，所以 在静态方法中不允许使用this/super之类用于指定对象的关键字

public class B{
private Random random; 
public static void pp() {
System.out.println("pp....");
//静态方法的调用没有要求必须构建B对象，所以很有可能random根本不存在，要求在静态方法 中不能访问非静态成员
// System.out.println(random);
// 在static方法中不允许出现this或者super关键字
}
public static void main(String[] args) {
B.pp();//调用当前类中的static方法，可以直接写方法名称pp()
}
}

当然在静态方法中允许创建对象，并调用对象方法
静态方法只能直接访问静态成员，不能直接访问非静态成员

静态块

public class A{
static { //类内，所有方法之外
System.out.println("静态代码块");
}
}

类在执行时需要通过一个叫作类加载器的组件将程序加载到内存中，类在运行时一般不会发生变化，所以类 不会频繁加载，在整个运行过程中只加载一次，而且常驻内存

静态块在类加载完毕后自动执行，而且只执行一次

public class B{
static {
System.out.println("static...");
}
public static void main(String[] args) {
}
}

非静态块

非静态块在类内且在所有的方法之外，非静态块并不会在类加载后自动执行，而是在构建当前对象时自动执行。 new一次则会执行一次，执行时机在构造器之前执行

public class A1 {
public static B1 bb=new B1();
static { 
//当类加载完毕自动执行，在整个类的使用过程中只执行一次 
//static块和静态属性执行的优先级相同，谁定义时在前先执行谁
System.out.println("A1.static");
}
{
//在构建对象时自动执行，在这个对象的生命周期中执行且只执行一次 
System.out.println("A1 non static");
}
//非静态代码块和非静态属性在构造器之前执行
public A1() {
System.out.println("this is A1..."); 
public C1 cc=new C1();
public static void pp() {
}
//静态方法只能直接访问静态成员
// System.out.println(age);
A1 aa=new A1();
System.out.println(aa.cc);
//不能出现this和super
// System.out.println(this);
System.out.println(bb);
System.out.println("this is A1.pp...");
public static void main(String[] args) {
}
// A1.pp();或者 pp();
A1 aa=new A1();
A1 aa1=new A1();
 A1 aa2=new A1();
 }
 }
 class B1{
 public B1(){
 System.ou.priontln("this is B1...");
 }
 }
 class C1{
 public C1() {
 System.out.println("this is C1...");
 }
 }

使用注意事项

静态方法只能访问静态成员，静态有访问局限性

静态方法中不能有this super关键字

主函数是静态的

什么时候使用静态
当成员变量的数据在当前类的各个对象都相同时，可以用static修饰的，让多个对象共享

非静态方法的调用没特殊要求，构建对象后即可调用；静态方法可以通过类名称直接调用，无需创建对象

非静态方法可以使用静态或者非静态成员；静态方法只能访问静态成员

如果类中的功能都是静态的，那么该类创建对象是没有意义的，所以构造方法需要私有化

方法中的可变长个数的参数

语法：数据类型… 变量名。－必须作为最后一个参数出现

具体处理过程中实际上是按照数组的方式进行处理，而且数组不会为null

public void pp(int... k1){
if(k1.length>0){
for(int i=0;i<k1.length;i++)
System.out.println(k1[i]);
}
}

void pp(Object… arr)可变长参数可以是Object[] 数组
注意：一个方法的最后一个位置只有一个，所以方法中的可变个数的参数只能有一个

static相关问题
父类中定义的静态方法（类方法）是否可以通过”子类名.静态方法名”的方式进行调用? 可以，因为继承的特性

public class Test1 {
public static void main(String[] args) {
Son.pp(); 
}
class Fa{
 public static void pp(){
 System.out.println("Fa.pp()");
 }
 }
 class Son extends Fa{}

静态导入

在一个类中反复使用到某个类中的静态方法，如果使用静态导入则在当前类中不需要再写类名称
double a1=-12.345;
System.out.println(Math.abs(a1));
System.out.println(Math.cos(a1));
System.out.println(Math.sin(a1));

在JDK5当中提供了导入静态方法的import语句。
语法：import static java.lang.Math.*; - 导入Math类中的所有静态方法

如果有多个静态导入操作，则所声明的静态方法不能重复，否则报错

注意要求使用JDK1.5+版本，否则编译不通过

import static java.lang.Math.*;
public class Test1 {
public static void main(String[] args) {
double a1 = -12.345;
System.out.println(abs(a1));
 System.out.println(cos(a1));
  System.out.println(sin(a1));
  }
  }

基本数据类型的对象缓存

在Integer类定义中查看源代码可以发现一个定义

private static class IntegerCache {}这实际上就是Integer的cache

Integer num1 = 12; 
//自动装箱 
Integer num2 = 12; //块相等，<=127都是真的 
System.out.println(num1 == num2);

是因为在Integer中包含有一个缓存池，缓存值为-128到127之间。

定义Integer k1=12是先在缓存池中查找12这个对象，如果有则直接使用

new Integer(12)一定会引发对象的创建，而不管缓存池中是否包含这个对象