java static一些知识点

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

import org.omg.CORBA.portable.InputStream;

//test1
//测试的目的是：静态变量在内存中只分配一块即共享一块内存
//目标：想获取静态变量的内存地址。
//结果失败：原因：java里不支持。
/**public class TestStatic {
 //public static int sid=0;
 public int sid=0;
 public static String name="";
 /*TestStatic(int sid ,String name){
  this.sid=sid;
  this.name=name;
 }*/

/**public static void main(String [] args){
 TestStatic ts1=new TestStatic();
 TestStatic ts2=new TestStatic();
 TestStatic ts3=new TestStatic();
 TestStatic ts4=new TestStatic();
 System.out.println(ts1+"=======1");//获取对象的地址
 System.out.println(ts2);
 System.out.println(ts3+"=======3");
 System.out.println(ts4+"=======4");
}
}
/*class Cat{
 public static int sid=0;
 String name;
 
}*/
/*结果：
 TestStatic@192d342=======1
 TestStatic@6b97fd
 TestStatic@1c78e57=======3
 TestStatic@5224ee=======4
 */

//test2:静态变量用于数据的累加
//测试发现：静态变量共享一个储存空间，当c1或c2的值改变时，c1或c2也会改变
//结果：成功
/**public class TestStatic{
 public static void main(String [] args){
  Cat.sid=1;
  Cat c1=new Cat("maomao");
     Cat.sid=10;
  Cat c2=new Cat("pingping");
  System.out.println(c1.name +"编号："+c1.sid);
  System.out.println(c2.name+"编号："+c2.sid);
 }
}
class Cat{
 public static int sid=0;
 String name;
 Cat(String name){
  this.name=name;
  sid++;
 }
}
/*out:maomao编号：11
     pingping编号：11*/

//test3:非静态变量
public class TestStatic {
 public static void main(String [] args) throws IOException{
  String catname = null;
  char   cn;
  System.out.println("请输入猫的名字");
  //Scanner sc=new Scanner(System.in);
  //catname=String.valueOf(sc.nextInt());
  //catname=String.valueOf(i);
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  catname=br.readLine();
  Cat cat1=new Cat();
  cat1.setName(String.valueOf(catname));
  System.out.println("==============================");
  System.out.println(cat1.getName());
  System.out.println("ddddddd"+cat1.sid);
  System.out.println("==============================");
  Cat cat2=new Cat();
   cat2.sid=2;
  cat2.setName(String.valueOf(catname));
  System.out.println(cat2.getName());
  System.out.println("ddddddd"+cat2.sid);
 }
}
class Cat{
 public int sid=0;
 String name;
    public void setName(String name){
     this.name=name;
     sid++;
    }
    public String getName(){
     return name;
    }
}
/**建议在具备下列全部条件的情况下，尽量使用静态变量：

（1）变量所包含的对象体积较大，占用内存较多。

（2）变量所包含的对象生命周期较长。

（3）变量所包含的对象数据稳定。

（4）该类的对象实例有对该变量所包含的对象的共享需求。

如果变量不具备上述特点建议你不要轻易地使用静态变量，以免弄巧成拙。
*/

 

 

//完善test2
//主题：一个static域无论他创建了多少个对象他只有一个实例
//题目：编写一个程序,展示无论你创建了某个类的多少个对象,这个类中的某个static域只有一个实例
/*思路：设置一个测试对象,该对象中含有一个静态字段a,和一个静态方法incrementA(对a执行加1操作),
 * 创建俩个该类的对象,在用类名称,对象o1和o2分别执行incrmentA操作后,,若输出a的结果一致,证明a只存在一个实例.
 */
public class TestStatic{
 public static void main(String [] args){
  System.out.println("输出sid的初始值ObiectTest.sid:"+ObiectTest.sid);
  ObiectTest ot1=new ObiectTest();
  ObiectTest ot2=new ObiectTest();
  System.out.println("输出ot1的值:"+ot1.sid);
  System.out.println("输出ot2的值:"+ot2.sid);
  System.out.println("输出当ot1调用incrementA方法后ot1、ot2的值");
  ot1.incrementA();
  System.out.println("输出当ot1调用incrementA方法后ot1的值:"+ot1.sid);
  System.out.println("输出当ot1调用incrementA方法后ot2的值:"+ot2.sid);
  ot2.incrementA();
  System.out.println("输出当ot2调用incrementA方法后ot1的值:"+ot1.sid);
  System.out.println("输出当ot2调用incrementA方法后ot2的值:"+ot1.sid);
 }
}
class ObiectTest{
 public static int sid=0;
 public static int incrementA(){
  return sid++;
 }
}
//out:
// 输出sid的初始值ObiectTest.sid:0
// 输出ot1的值:0
// 输出ot2的值:0
// 输出当ot1调用incrementA方法后ot1、ot2的值
// 输出当ot1调用incrementA方法后ot1的值:1
// 输出当ot1调用incrementA方法后ot2的值:1
// 输出当ot2调用incrementA方法后ot1的值:2
// 输出当ot2调用incrementA方法后ot2的值:2