Java--- final static

final关键字

  • 最终类,不能有子类,不可以被继承,例:String
    但是使用方式,没有变化。
    • 修饰方法,子类可以继承,但不能重写。
public class Fu{
    public final void show{
              System.out.println("fu类的最终方法。"); 
     public void  function(){
  System .out.println( "fu类的一般方法。");
}
} 
 
 public class Zi extends Fu{  

          public  void function{
               System.out.println("Zi类的一般方法。");
} 
} 
 
 *测试* 
  
  public class Test{
         public static void main(String[  ]    args){
             zi      z=new  zi( );
             z.function ( );
             z.show( );        

}
}
  • final 修饰的变量为常量,这些变量只能被赋值一次
  • final修饰成员变量,在堆内存,具有默认值,final修饰的成员变量,固定的不是内存的默认值,固定的是,成员变量的手动赋值,绝不是内存的默认。
  • 成员变量的赋值:::一种是定义时,直接=赋值。一种采用构造方法赋值
  • 成员变量,需要在创建对象赋值

static关键字

  • 被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)
  • 对象的特有数据(非静态修饰)调用者只能是new 对象
  • 对象的共享数据(静态修饰) 调用者可以new对象,也可以是类名(被静态修饰的成员,可以被类名直接调用)
public class Person {
     String name;//自己的
     static String className;//共享的

} 
 
  public class Test{
         public static void  main (String[  ] args) 
         person p1=new Person( );
         person p2= new Person( );
           p1.name="哈哈";
           p2.name="嘻嘻";
           System.out.println(p1.name);
                System.out.println(p2.name);
           //调静态 
            p1.className="基础班"; 
            System.out.println(p2.className);
}
 
  
  
-------------------------------------------------------------- 
运行结果: 
  哈哈 
  嘻嘻 
  基础班
  

1.格式

类名.静态成员变量名
类名.静态成员方法名(参数)

2.问:为什么静态不能调用非静态
答:因为其生命周期,静态优先于非静态

3.静态不能写this,不能写super

4.static什么时候使用?
static 修饰成员变量,成员方法
成员变量加static,根据具体事物(多个事物是否有共性的数据)分析决定

5.成员方法加static,跟变量走,如果方法,没有调用过非静态成员,将方法定义成静态

对象中的静态调用


 public class Fu{
          static int i = i; 
            
            public static  void show( ){
                   System.out.println("父类静态方法show");
}
} 
 
       public class Zi extends Fu{
               static int i =2; 
                public static void show(){
                      System .out.println("子类的静态方法show");
}   
} 
 
             public class Test{
               public static  void main(String[ ]   args){
                          Fu f=new Zi(); 
                           System.out.println(f.i);  
                           //调用还是父类的静态方法,原因::静态属于类,不属于对象 
                           //对象的多态性,静态和对象无关,父类的引用,静态方法
                             f.show();
}
}
  

多态调用中,编译看谁?运行看谁?

  • 编译看=左边的父类,父类有编译成功,父类没有,编译失败

    • 运行,静态方法,运行父类中的静态方法
    • 运行,非静态方法,运行子类的重写方法
    • 成员变量,编译运行全是父类

    定义静态常量

    • 格式:public static final 数据类型 变量名= 值;
    • 当我们想使用类的静态成员时,不需要创建对象,直接使用类名来访问即可
    • 注意:
      接口中的每个成员变量都默认使用public static final修饰。
      所有接口中的成员变量已是静态常量,由于接口没有构造方法,所以必须显示赋值。
      可以直接用接口名访问。
interface Inter {
	public static final int COUNT = 100;
}  

	 访问接口中的静态变量
Inter.COUNT
发布了43 篇原创文章 · 获赞 6 · 访问量 1563

猜你喜欢

转载自blog.csdn.net/weixin_43729631/article/details/84843914