静态static与方法重载

一.静态static

     在介绍静态变量、常量和方法以前首先须要介绍static关键字，由于由static修饰的变量、常量和方法被称做静态变量、常量和方法。

     有时在处理问题时，会须要两个类在同一个内存区域共享一个数据。例如，在球类中使用PI这个常量，可能除了本类须要这个常量以外，在另一个圆类中也须要使用这个常量。这时没有必要在两个类中同时建立PI这个常量，由于这样系统会将这两个不在同一个类中定义的常量分配到不一样的内存空间中。为了解决这个问题，能够将这个常量设置为静态的。

如图：

    被声明为static的变量、常量和方法被称做静态成员。静态成员是属于类全部的，区别于个别对象，能够在本类或其余类使用类名和“.”运算符调用静态成员。

    语法格式为：    类名.静态类成员

    注意：虽然静态成员也可使用“对象.静态成员”的形式进行调用，但这样的形式一般不被鼓励使用，由于这样容易混淆静态成员和非静态成员。

    静态数据与静态方法的做用一般是为了提供共享数据或方法，如数据计算公式等，一static声明并实现，这样当须要使用时，直接使用类名调用这些静态成员便可。尽管使用这种方式调用静态成员比较方便，但静态成员一样遵循着public、private、protected修饰符的约束。

    静态方法的规范：

    1.能够放在常量、变量、方法前；

    2.全部对象都共享一个静态成员；

    3.能够用类名.静态成员名  直接调用；

    4.静态方法不能直接调用非静态的成员；

    5.实例方法能够直接调用静态成员；

    6.静态方法里不能用this；

    7.实现单例模式:

      (1)隐藏默认的构造方法;

      (2)开放一个静态方法返回实例;

      (3)在类的内部准备一个实例;

      (4)判断类内部的实例是否已实例化:

            1°.未实例化时进行一次实例

            2°.已实例化时直接返回这个实例

 

静态单例模式的类：

 1 package org.hanqi.pn0120;
 2 
 3 public class JingTai {
 4     
 5     public int a=0;
 6     
 7     public static int b=0;//静态属性
 8     
 9     public void add()
10     {
11         a++;
12         
13         System.out.print("a="+a);
14         
15         b++;
16         
17         System.out.println("  b="+b);
18         
19         add1();
20         
21         //this
22     }
23     
24     public static void add1()
25     {
26         b++;
27         
28 //        
29 //        JingTai t=new  JingTai();
30 //        
31 //        t.add();
32 //        a++;
33         
34     }
35 
36 }

JingTai

 1 package org.hanqi.pn0120;
 2 
 3 public class DanLi {
 4     
 5     //单例模式
 6     //只被实例化一次
 7     
 8     //获取系统的配置信息
 9     
10     //1.隐藏默认构造方法
11     private  DanLi()
12     {
13         
14     }
15     //3.准备一个实例
16     private static DanLi danli;
17     
18     //2.提供一个静态方法返回类的实例
19     public static  DanLi  init()
20     {
21         //实例化惟一的对象
22         //DanLi d=new  DanLi();
23         
24         //4.判断是否已被实例化
25         if(danli==null)
26         {
27             danli=new DanLi();
28         }
29         
30         return danli;
31     }
32 
33     private int a=0;
34     
35     public void add()
36     {
37         a++;
38         
39         System.out.println("a="+a);
40     }
41 }

DanLi

 1 package org.hanqi.pn0120;
 2 
 3 public class TestJingTai {
 4 
 5     public static void main(String[] args) {
 6         
 7         for(int i=0;i<10;i++)
 8         {
 9         JingTai t1=new JingTai();
10         
11         t1.add();
12         }
13         
14         JingTai t2=new JingTai();
15         
16         t2.add();
17         
18     
19         JingTai.b+=1;
20         
21         System.out.println("JingTai.b="+JingTai.b);
22         
23         JingTai.add1();
24     
25         System.out.println("JingTai.b="+JingTai.b); 
26         
27         DanLi d=DanLi.init();
28         d.add();
29         DanLi d1=DanLi.init();
30         d1.add();
31         DanLi d2=DanLi.init();
32         d2.add();
33     }
34 
35 }

TestJingTai

 

二.方法重载

    1.在一个类里面，同名的方法，参数形式不一样:类型不一样，数量不一样。

       这是多态的表现。

    2.使用

       （1）通常把业务逻辑写在参数最全的方法里

       （2）其余用重载方法，减小参数的数量

       （3）调用参数多的方法，不够的参数用默认值

    注意：不能经过返回值不一样来区分不一样的方法。

 重载的类：

 1 package org.hanqi.pn0120;
 2 
 3 public class JiSuanQi {
 4     
 5     //整型加法
 6     public int add(int a,int b)
 7     {
 8         return a+b;
 9     }
10     
11     //重载 参数个数不一样
12     public double add(int c,int d,int e)
13     {
14         return c+d+e;
15     }
16     
17     //浮点型加法  方法的重载（多态的一种体现）
18     //参数类型不一样
19     public double add(double a,double b)
20     {
21         return a+b;
22     }
23 
24     public static void main(String[] args) {
25 
26 
27         JiSuanQi j=new JiSuanQi();
28         
29         System.out.println("20+50="+j.add(20, 50));
30          
31         System.out.println("20.12+50.45="+j.add(20.12, 50.45));
32         
33         
34     }
35 
36 }

JiSuanQi

 

 

   

综合：