Java常见关键字及其用法(上)

原创
2019/11/08 23:28
阅读数 47
  1. final
  2. static
  3. this
  4. super

1.final(四种用法)

1.修饰局部变量(只能一次赋值,终生不变)

  • 修饰基本数据类型:修饰的数据变量值不可变
  • 修饰引用数据类型:地址值不可变,内容可以变

注意事项:

  1. 1 错误:
 public static void main(String[] args) {
        final int c = 0;
        for (int i=0;i<10;i++)
        {
            c=i;                        //错误:无法为最终变量c分配值
        }
    }

  1. 2正确:
 public static void main(String[] args) {
        for (int i=0;i<10;i++)
        {
            final int c = 0;            //正确:局部变量,每次循环释放掉
        }
    }

2. 修饰成员变量变量的数据值不可变

  • 成员变量有默认值,final修饰后需要手动赋值
  • 通过构造方法对final修饰的成员变量进行赋值,需要保证所有重载的构造方法对final修饰的成员变量进行赋值,保证其修饰变量的初始化

选其一:

public class Demo {
    private final String name = "桑凤娇";//直接赋值
    public Demo(){}
    }

public class Demo2 {
    private final String name ;
public Demo2()
	{
    		name = "桑凤娇";//通过构造方法赋值
	}
 public Demo2(String name) {
        this.name = name;//通过构造方法赋值
    }
}

3.修饰类

用final修饰的这个类不能有任何子类

注意:一个类如果是final修饰的,其中所有的成员方法都无法进行覆盖(因为没有子类)

  • 被final修饰的类,final类中的成员变量可以根据自己实际需要设计成final
  • final类中的成员方法都会被隐式指定为final方法

修饰方法

用final修饰的方法不能被覆盖(不能重写:override)

2.static

static修饰的内容(随类的加载而加载,且加载一次;存储于固定的内存区域(静态区),所以直接用类名进行调用;优先于对象存在,所以可以被所有对象共享)

修饰成员变量和成员方法,其中被修饰的成员都属于类,而不是单单属于某个对象,使用时用类可以直接调用,而不需要创建对象

  • 类变量定义格式:static int num = 10;(static 数据类型 变量名;)
  • 类方法定义格式:public static 返回值类型 方法名(){ }

 

  1. 没有被static修饰的成员变量称为实例变量,实例变量属于某个对象
  2. 类方法使用及其注意事项:

使用:

  • static修饰的方法都属于静态方法(类方法),使用类名.方法名调用
  • 定义格式:public static 返回值类型 方法名(参数列表){}

注意:

package com.day02;
/**
 * @author SFJ
 * @date 2019/11/8
 * @time 22:19
 **/
public class Test1 {
    private String name="桑凤娇";
    static String idCard ="3709211998092033**";
    public static void method1()
    {
        method2();//错误,静态方法不可以直接访问非静态成员方法
        new Test1().method2();//正确,静态方法创建匿名对象访问非静态成员方法
        System.out.println(name);//错误,不可以直接访问非静态成员变量
        System.out.println(idCard);//正确,可以直接访问静态成员变量
    }
    public void method2()
    {
        System.out.println(idCard);//正确,非静态方法可以访问静态变量
        method1();//正确,非静态方法可以访问静态方法
    }
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.method2();
    }
}
  • 静态方法不能直接访问普通变量和成员方法,需要创建对象进行访问
  • 静态方法可以直接访问静态方法和静态成员变量
  • 在非静态方法中可以访问静态方法和静态成员变量
  • 在静态方法中,不能直接使用super和this关键字

静态代码块:

  • 定义在类的内部,任何方法的外部
  • 定义格式: static{}

主要作用是给类变量进行初始化赋值

3.this(表示对当前对象的引用)

  • 区分同名的函数参数和成员变量(this.成员变量名=参数----最常用)
  • 在构造方法中(this()或者this(参数列表),只能引用一个构造方法且只能在第一句)
  • 注意:this不能用在static修饰的方法中,因为static修饰的方法属于类,而this指的是对对象的引用,冲突矛盾
  • package com.day02;
    
    /**
     * @author SFJ
     * @date 2019/11/8
     * @time 22:53
     **/
    public class Test3 {
            private int i=0;
            Test3(int i) {//第一个构造器:有一个int型形参
                this.i = i + 1;//此时this表示引用成员变量i,而非函数参数i
                System.out.println("Int constructor i——this.i:  " + i + "——" + this.i);
                System.out.println("i-1:" + (i - 1) + "this.i+1:" + (this.i + 1));
                //从两个输出结果充分证明了i和this.i是不一样的!
            }
            Test3(String s){ //  第二个构造器:有一个String型形参
                System.out.println("String constructor:  "+s);
            }
            Test3(int i,String s){//  第三个构造器:有一个int型形参和一个String型形参
                this(s);//this调用第二个构造器
                this.i=i++;//this以引用该类的成员变量
                System.out.println("Int constructor:  "+i+"/n"+"String constructor:  "+s);
            }
            public Test3 increment(){//增量
                this.i++;
                return this;//返回的是当前的对象,该对象属于(Test3)
            }
            public static void main(String[] args){
                Test3 t0=new Test3(21);
                Test3 t1=new Test3("桑凤娇");
                Test3 t2=new Test3(21,"桑凤娇");
                System.out.println(t1.increment().increment().increment().i);
                //t0.increment()返回一个在t0基础上i++的Test3对象,
                //接着又返回在上面返回的对象基础上i++的Test3对象!
            }
    
        }

     

4.super(表示父类的引用)

  • 子父类存在着同名的成员(包括变量和方法)时,在子类中默认是访问子类的成员,可以通过super关键字指定访问父类的成员;
  • 创建子类对象时,默认会先调用父类无参的构造方法,可以通过super关键字指定调用父类的构造方法:
  1. 如果在子类的构造方法上没有指定调用父类的构造方法,jvm会在子类的构造方法内加上super()语句
  2. super关键字调用父类构造函数时,该语句必须要是子类构造函数中的第一个语句
  3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句
  4. 继承中,只要创建子类对象,默认一定会先调用父类无参构造方法创建父类对象
    package com.day02;
    
    /**
     * @author SFJ
     * @date 2019/11/8
     * @time 23:08
     **/
    public class Test4 {
        public static void main(String[] args) {
            Son s = new Son(3);
            System.out.println();  //4   
        }
    }
    class Father {
        int x = 1;
        Father() {
            System.out.println("父类无参的构造方法");
        }
        Father(int x) {
            this.x = x;
            System.out.println("父类有参的构造方法");
        }
        void speak() {
            System.out.println("我是父类");
        }
    }
    class Son extends Father {
        int y = 1;
        Son() {
            System.out.println("子类无参的构造方法");
        }
        Son(int y) {
            this.y = y+x;
            System.out.println("子类带参的构造方法");
        }
        void run() {
            super.speak(); //访问父类的函数
            System.out.println("我是子类");
        }
    }
  •  

 

展开阅读全文
加载中
点击引领话题📣 发布并加入讨论🔥
打赏
0 评论
0 收藏
1
分享
返回顶部
顶部