Java_总结九（面向对象遗漏知识点——this 关键字、static 关键字、代码块、final 关键字、instanceof 关键字、super 关键字）

一、this关键字

　　--强调本类中的方法（this.方法）

　　--表示类中的属性（this.成员属性）

　　--调用本类的构造方法（this()）

　　--this 表示当前对象

public class Test07 {
    private String name;
    public Test07() {
        //构造方法
    }
    
    public Test07(String name) {
        this();    //表示调用本类无参构造方法，只能放在构造方法的首行，而且类中必须存在一个没有使用this调用构造方法的构造方法
        this.name = name;
    }

    public void setName(String name) {        
        this.name = name;    //this.name 表示本类成员属性
    }
}

 

二、static 关键字

　　静态属性（全局属性）

 　　　　--静态属性声明：static  类型  大写静态属性名  =  值；

　　　　 --静态属性调用：类名 . 大写静态属性名

　　　　 --有些属性希望被所有对象共享，则必须将其声明为 static 属性public class Test07 {

public static void main(String[] args) {
        Test_Static.COUNT = 5;//静态属性通过类名调用
        Test_Static ts1 = new Test_Static();
        Test_Static ts2 = new Test_Static();
        System.out.println("ts1调用COUNT——"+ts1.COUNT);
        System.out.println("ts2调用COUNT——"+ts2.COUNT);
        
        ts1.COUNT = 10;    //通过对象ts1改变一次静态变量的值，ts2调用COUNT值也是10，证明static属性是一个类中多个对象的共享资源
        System.out.println("ts1调用COUNT——"+ts1.COUNT);
        System.out.println("ts2调用COUNT——"+ts2.COUNT);
    }
}

class Test_Static{
    static int COUNT = 4;
}

结果：
　　ts1调用COUNT——5
　　ts2调用COUNT——5
　　ts1调用COUNT——10
　　ts2调用COUNT——10

 

 　　静态方法

 　　　　--静态方法只能调用静态方法和静态属性

　　　　 --普通方法可以调用静态方法和静态属性

public class Test_Static{
    static int COUNT = 4;
    int a;
    public static void print(){
        //int b = a;//这里a的调用时错误的
        int b = COUNT;
        //sum();//sum()不是静态方法，错误
        add();
    }
    
    public void sum() {
        System.out.println("我是普通方法1");
    }
    
    public void sum2() {
        add();
        print();//普通方法可以调用静态方法
        int a = COUNT;//普通方法可以调用静态属性
        System.out.println("我是普通方法2");
    }
    
    public static void add(){
        System.out.println("我是静态方法");
    }
}

 

 三、代码块

　　--代码块分为普通代码块、构造块、静态代码块、同步代码块 4 种

 　　

　　代码块的执行顺序和次数：

package chapter.three;

public class Test08 {
    
    static{        //在主方法中定义静态代码块
        System.out.println("主方法中定义静态代码块");
    }
    public static void main(String[] args) {
        new Demo();
        new Demo();
        new Demo();
    }
}

class Demo{
    {            //定义构造块
        System.out.println("1、构造块");
    }
    
    static{            //定义静态代码块
        System.out.println("0、静态代码块");
    }
    
    public Demo(){            //定义构造方法，构造块
        System.out.println("2、构造方法");
    }
}

　　执行结果：

主方法中定义静态代码块
0、静态代码块
1、构造块
2、构造方法
1、构造块
2、构造方法
1、构造块
2、构造方法

　　从程序运行结果中可以发现，静态代码块优先于主方法执行，而在类中定义的静态代码块会优先于构造块执行，而且不管有多少个对象产生，静态代码块只执行一次。

 

四、final 关键字

　　final 是最终的意思，也可以称为完结器

　　　　--使用 final 声明的类不能有子类

　　　　--使用 final 声明的方法不能被子类所覆写（注意：不是不能继承，而是不能被重写）

　　　　--使用 final 声明的变量即成为常量，这个常量不可以修改

　　　　--被 final 声明的变量，名称要全部大写，此变量被称为全局常量（而只有 static 修饰的，称为全局属性，是可以修改值得）

    public static final int COUNT = 10;

 

五、instanceof 关键字

　　instanceof 的作用：判断一个对象到底是哪个类的实例（一般作为条件判断用）

    //格式
    对象 instanceof 类名   ——> 返回 boolean 类型

　　

　　面向对象中对象向下转型实例

package chapter.three;

public class Test09 {

    public static void main(String[] args) {
        Father father = new Son();//对象向上转型没问题
        //对象向下转型，需要先用 instanceof 判断
        if (father instanceof Son) {
            Son son = (Son) father;
        }
    }
}
class Father{
    
}

class Son extends Father{
    
}

 

六、super 关键字

　　--在Java类中使用super来引用父类的成分 super.

　　--可用于访问父类中定义的属性Demo super.

　　--可用于调用父类中定义的成员方法Demo

　　--super(...)可用于在子类构造器中调用父类的构造器Demo

 

　　注意点：

　　　　super只能应用在成员方法和构造方法中，不能应用在静态方法中（和this是一样的），如果在构造方法中使用super(...)必须放在第一行。