java基础9 main函数、this、static、super、final、instanceof 关键字

一、main函数详解

1.public:公共的.权限是最大的,在任何情况都可以访问
原因:为了保证jvm在任何情况下都可以访问到main法
2.static:静态,静态可以让jvm调用更方便,不需要用对象调用
3.void:没有返回值.因为返回的数据是给jvm,而jvm使用这个数据是没有意义的,所有就不要了
4.main:函数名, 注意:main方法并不是关键字,只不过是jvm唯一识别的一个特殊函数名
5.arguments(args):担心某些程序启动时需要参数.

class Demo1 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

二、this关键字

2.1 this 的概述

this关键字代表是对象的引用。也就是this在指向一个对象，所指向的对象就是调用该函数的对象引用。（this关键字代表了所属函数的调用对象）

2.2 this关键字的作用

   1.如果存在同名的局部变量和成员变量时,在方法内部默认访问的是局部变量的数据
      可以通过this关键字指定访问成员变量的数据
   2.this关键字在构造函数中不能出现相互调用,因为是一个死循环。

class Student{
    int id;    //身份证 (成员变量)
    String name;//名字  (成员变量)
    //目前情况:存在同名的局部变量和成员变量,在方面内部默认使用的局部变量的.
    public Student(int id,String name){//局部变量
        this.name = name;//把局部变量name的数据传给成员变量name
        this.id = id;    
    }
}
class Demo8 {
    public static void main(String[] args) {
        Student s=new Student(12580,"王麻子");        
        System.out.println(s.id+"\t"+s.name);
    }
}

2.3 this关键字要注意的事项

1.如果在一个方法中访问一个变量时,该变量只存在成员变量的情况下,那么java编译器会自动在该变量前添加this关键.

2.this只能在非静态（没有static修饰的）函数中使用.

3.在一个构造函数中如何调用另一个构造函数的格式: this()无参构造器,this(参数...)有参构造器......。
一个构造器调用另一个构造器(方法/函数): this()关键字必须位于第一个语句,否则编译错误

class Student{
    int id;    
    String name;
    //目前情况:存在同名的局部变量和成员变量,在方面内部默认使用的局部变量的.
    public Student(int id,String name){//全参构造器
        this(name);//调用的是:含有参数name的构造器
        this.name = name;
        this.id = id;
    }
    //无参构造器
    public Student(){

    } 
    //含一个参数的构造器
    public Student(String name){
        this.name=name;//把局部变量给了成员变量name
    }
}
class Demo8 {
    public static void main(String[] args) {
        Student s=new Student(250,"王麻子");        
        System.out.println(s.id);
    }
}

三、static关键字

3.1 static修饰成员变量时

static修饰成员变量时,那么该成员变量数据就是一个共享数据;
静态成员的访问方式:
       方式一: 使用对象进行访问
                   对象.变量名
        方式二: 使用类名进行访问
                   类名.变量名
注意:
       非静态成员变量,只能使用对象进行访问,不能使用类名访问。千万不要为了方便访问变量而使用static修饰,一定要是该数据是共享的数据时才使用static修饰

3.2 static修饰方法(静态成员方法)

静态方法的访问方式:
       方式一: 可以使用对象调用
               对象.静态的方法名();
       访问方式二: 可以使用类名调用
               类名.静态方法名();

class Student{
    String name;
    static String country="中国";
    //静态方法(函数)
    public static void study(){
        System.out.println(country+"努力学习");
    }
    //有参构造器
    public Student(String name){
        this.name=name;
    }
    //无参构造器
    public Student(){
    }
    //普通方法(函数)
    public void eat(){
        System.out.println(country+name+"努力学习");
    }
}

class Demo9 {
    public static void main(String[] args) {
        Student s=new Student("铁蛋");
        s.eat();//用对象名调用
        Student.study();//用类名直接调用
        s.study();

        Student s1=new Student();
　　　　 s1.name = "狗娃";//用对象名调用
        Student.name = "狗蛋";//用类名直接调用;此处报错,原因:成员变量name不是静态变量,静态方法不能直接用类名调用,要用对象名调用
        System.out.println(s1.name+"\t"+Student.country); //Student.country:不报错的原因:因为country是静态成员变量,所以可以用类名调用
    }
}

3.3 静态的成员变量和非静态的成员变量区别

1.作用上区别:
1.静态成员变量的作用共享一个数据给所有对象使用
2.非静态成员变量的作用是描述一类事物的公共属性
2.数量与存储的位置的区别:
1.静态成员变量存储在方法区内存中,而且只会存储一份数据
2.非静态成员变量存储在堆内存中,有n个对象就会有n份数据
3.生命周期的区别:
1.静态的成员变量数据是随着类的加载而存在,随着类文件的消失而消失
2.非静态的成员变量数据是随着对象的创建而存在,随着对象的消失而被垃圾回收器回收掉

3.4静态函数要注意的事项

1.静态函数可以通过类名或者对象进行访问,而非静态的只能通过对象进行访问.
2.静态的函数是可以直接访问静态的成员的,但是不能访问非静态的成员;
原因:静态成员可以直接使用类名调用,这个时候可能还没有存在对象,
    而非静态的成员是随着对象的创建而存在的
3.非静态的函数是可以直接访问静态和非静态的成员的.
原因:非静态函数只由对象调用,当对象存在时,静态的数据老早就存在了,
   而非静态的数据也随着对象的创建而存在了
4.静态函数不能出现this或者super关键字
原因:因为静态函数是可以使用类名调用的,一旦使用类名调用,这个时候可能不存在对象,而this
   关键字代表了一个函数的调用者对象,这个时候就会产生冲突

3.5 静态数据生命周期

静态的成员变量数据是先于对象存在的

四、super关键字

4.1、概念：

super关键字代表了父类空间的引用

4.2、super关键字的作用

　 1.子父类中存在这同名的成员时,在子类中默认访问子类的成员,可以通过super关键字访问父类指定父类成员
2.创建子类对象时,默认调用父类的无参构造器,可以通过super关键字调用父类中有参构造器

4.3、super关键字调用父类的构造方法时，要注意的事项

　 1.在子类的构造器中没有指定调用父类的构造方法,那么编译器会在子类构造器中默认添加一个super()
2.super关键字调用父类构造函数时,该语句必须要是子类函数的第一语句
3.super关键字与this关键字不能同时出现在一个构造函数中调用其他构造函数.因为两个语句都需要是第一个语句(第一行)

五、super关键字与this关键字的区别

1.代表的事物不一致
   1.super关键字代表的是父类空间的引用.
   2.this关键字代表是所属函数的调用对象.
2.使用的前提不一样
   1.super关键字必须要有继承关系才能使用
   2.this关键字不需要存在继承关系也可以使用
3.调用构造函数的区别
   1.super关键字是调用父类的构造函数
   2.this关键字是调用本类的构造函数.

 //例子：super和this关键字
 1 class Fu{
 2     int x=10;
 3     String name;
 4 
 5     public Fu(){
 6         System.out.println("父类无参构造器....");
 7     }
 8     public Fu(String name){
 9         this.name=name; //把局部变量name的数据传给成员变量name
10     }
11     public void eat(){
12         System.out.println("小头爸爸吃番薯......."+name);
13     }
14 }
15  
16  class Zi extends Fu {
17     int x=20;
18     int num;
19     public Zi(){
20         System.out.println("这是子类无参构造器...");
21     }
22     public Zi(String name,int num){
23         super(name); //指定调用父类的一个参数的构造器
24         super.eat();//调用父类中的eat() 方法
25     
26     }
27     
28     public void eat(){
29         System.out.println("大头儿子吃龙虾...."+super.x+"\t"+name); //和this关键字的用法相似，这里（super.x）调用的是父类中的成员变量x，返回结果：10；去掉super关键字，返回结果：20 (就近原则)
30     }
31  }
32 class  Demo7{
33     public static void main(String[] args) {
34         Zi z=new Zi("二狗子",2);
35         z.eat(); //这里调用的是子类的eat()方法
36     }    
37 }

结果图：

解析：

第一条结果：是子类实例化对象后（Zi z = new Zi("二狗子",2);），调用了子类的有参构造器（含两个参数的构造器），有参构造器的 “super(name)”再去调用父类中的含一个参数的构造器，才返回的第一条结果。

第二条结果：是直接调用子类中的 eat() 方法。（super.x）调用的是父类中的成员变量x，返回结果：10；去掉super关键字，返回结果：20 (就近原则)；

　　　　　　由于super(name)调用父类中的含一个参数的构造器，所以，相当于子类间接继承了父类中的含一个参的构造器，故name也有父类一样的值。

六、final 关键字

常量修饰符一般为：public static final

　　例如：public static final double PI = 3.14; //圆周率

（注：常量的命名规范：
　　全部字母都要大写,单词与单词之间使用下划线分割。）

final 关键字注意事项：

    1.final关键字修饰一个基本类型的变量时,该变量不能重新赋值,第一次的值为最终值
    2.final关键字修饰一个引用类型时,该变量不能重新指向新的对象.
    3.final关键字修饰一个函数时,该函数不能被重写
    4.final关键字修饰一个类时,该类就不能被继承

注：(基本类型包括：基本数据类型和引用数据类型，在java里面除去基本数据类型的其它类型都是引用数据类型，自己定义的class类都是引用类型，可以像基本类型一样使用。)

七、instanceof 关键字

1、instanceof关键字的作用

　　判断一个对象是否属于指定类型

2、instanceof使用的前提

　　判断对象与指定的类型必须是继承或者实现关系

3、instanceof的格式

　　对象 instanceof 类别

4、运用场景

　　多态

　　 //需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
    //instanceof
    public static void print(Animal a){ //相当于：Animal a=new Fish();
        if(a instanceof Fish){
             Fish f=(Fish)a;
             f.bubble();
        }else if(a instanceof Mouse){
            Mouse m=(Mouse)a;
            m.dig();
        }else{
            System.out.println("输入错误");
        }
    }

解析：当实例化一个对象：

　　 Animal a=new Mouse("米老鼠"); //多态,父类的引用指向子类的对象
       a.run();
       //a.dig(); //报错，因为是多态(父类中没有dig()方法)，所以要强制转换类型
       Mouse m=(Mouse)a; //强制类型转换
       m.dig();

完整例子：

 1 //动物类
 2 abstract class Animal{
 3     String name;
 4     public Animal(String name){
 5         this.name=name;
 6     }
 7 
 8     public abstract void run(); //抽象方法
 9 }
10 //老鼠类
11 class Mouse extends Animal{
12     public Mouse(String name){
13         super(name);
14     }
15     public void run(){
16         System.out.println(name+"四条腿慢慢走");
17     }
18 
19     public void dig(){
20         System.out.println(name+"老打洞...");
21 
22     }
23 }
24 //鱼类
25 class Fish extends Animal{
26     public Fish(String name){
27         super(name);
28     }
29     public void run(){
30         System.out.println(name+"摇着尾巴游啊游...");
31     }
32     public void bubble(){
33         System.out.println(name+"吹泡泡....");
34     }
35 }
36 
37 class Demo6 {
38     public static void main(String[] args) {
39         Animal a=new Mouse("米老鼠");//多态,父类的引用指向子类的对象
40         a.run();
41         //a.dig();报错
42         //调用
43         Mouse m=(Mouse)a;//强制类型转换  
44         m.dig(); //如果直接用a.dig()的话，会报错，因为是多态(父类中没有dig()方法)，所以要强制转换类型
45 
46         Animal a1=new Fish("金枪鱼");
47         Fish f=(Fish)a1;
48         print(f);
49     }
50 
51     //需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
52     //instanceof
53     public static void print(Animal a){ //相当于：Animal a=new Fish();
54         if(a instanceof Fish){
55              Fish f=(Fish)a;
56              f.bubble();
57         }else if(a instanceof Mouse){
58             Mouse m=(Mouse)a;
59             m.dig();
60         }else{
61             System.out.println("输入错误");
62         }
63     }
64 }