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{
     int x=10;
     String name;

     public Fu(){
         System.out.println("父类无参构造器....");
     }
     public Fu(String name){
         this.name=name; //把局部变量name的数据传给成员变量name
     }
     public void eat(){
         System.out.println("小头爸爸吃番薯......."+name);
     }
 }

  class Zi extends Fu {
     int x=20;
     int num;
     public Zi(){
         System.out.println("这是子类无参构造器...");
     }
     public Zi(String name,int num){
         super(name); //指定调用父类的一个参数的构造器
         super.eat();//调用父类中的eat() 方法

     }

     public void eat(){
         System.out.println("大头儿子吃龙虾...."+super.x+"\t"+name); //和this关键字的用法相似，这里（super.x）调用的是父类中的成员变量x，返回结果：10；去掉super关键字，返回结果：20 (就近原则)
     }
  }
 class  Demo7{
     public static void main(String[] args) {
         Zi z=new Zi("二狗子",2);
         z.eat(); //这里调用的是子类的eat()方法
     }
 }

 结果图：

解析：

第一条结果：是子类实例化对象后（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();

完整例子：

 //动物类
 abstract class Animal{
     String name;
     public Animal(String name){
         this.name=name;
     }

     public abstract void run(); //抽象方法
 }
 //老鼠类
 class Mouse extends Animal{
     public Mouse(String name){
         super(name);
     }
     public void run(){
         System.out.println(name+"四条腿慢慢走");
     }

     public void dig(){
         System.out.println(name+"老打洞...");

     }
 }
 //鱼类
 class Fish extends Animal{
     public Fish(String name){
         super(name);
     }
     public void run(){
         System.out.println(name+"摇着尾巴游啊游...");
     }
     public void bubble(){
         System.out.println(name+"吹泡泡....");
     }
 }

 class Demo6 {
     public static void main(String[] args) {
         Animal a=new Mouse("米老鼠");//多态,父类的引用指向子类的对象
         a.run();
         //a.dig();报错
         //调用
         Mouse m=(Mouse)a;//强制类型转换
         m.dig(); //如果直接用a.dig()的话，会报错，因为是多态(父类中没有dig()方法)，所以要强制转换类型

         Animal a1=new Fish("金枪鱼");
         Fish f=(Fish)a1;
         print(f);
     }

     //需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
     //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("输入错误");
         }
     }
 }

八、其他java关键字

1、super和extends关键字：http://www.cnblogs.com/dshore123/p/8805436.html

2、break和continue关键字：http://www.cnblogs.com/dshore123/p/8656779.html

3、abstract关键字：http://www.cnblogs.com/dshore123/p/8867093.html

4、interface、implements关键字：http://www.cnblogs.com/dshore123/p/8873647.html

5、throw、throws、finally关键字：http://www.cnblogs.com/dshore123/p/8927993.html

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：http://www.cnblogs.com/dshore123/p/8744330.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）

 

 

 

G

M

T

 

检测语言 世界语 中文简体 中文繁体 丹麦语 乌克兰语 乌兹别克语 乌尔都语 亚美尼亚语 伊博语 俄语 保加利亚语 僧伽罗语 克罗地亚语 冰岛语 加利西亚语 加泰罗尼亚语 匈牙利语 南非祖鲁语 卡纳达语 印地语 印尼巽他语 印尼爪哇语 印尼语 古吉拉特语 哈萨克语 土耳其语 塔吉克语 塞尔维亚语 塞索托语 威尔士语 孟加拉语 宿务语 尼泊尔语 巴斯克语 布尔语(南非荷兰语) 希伯来语 希腊语 德语 意大利语 意第绪语 拉丁语 拉脱维亚语 挪威语 捷克语 斯洛伐克语 斯洛文尼亚语 斯瓦希里语 旁遮普语 日语 格鲁吉亚语 毛利语 法语 波兰语 波斯尼亚语 波斯语 泰卢固语 泰米尔语 泰语 海地克里奥尔语 爱尔兰语 爱沙尼亚语 瑞典语 白俄罗斯语 立陶宛语 索马里语 约鲁巴语 缅甸语 罗马尼亚语 老挝语 芬兰语 苗语 英语 荷兰语 菲律宾语 葡萄牙语 蒙古语 西班牙语 豪萨语 越南语 阿塞拜疆语 阿尔巴尼亚语 阿拉伯语 韩语 马其顿语 马尔加什语 马拉地语 马拉雅拉姆语 马来语 马耳他语 高棉语 齐切瓦语

世界语 中文简体 中文繁体 丹麦语 乌克兰语 乌兹别克语 乌尔都语 亚美尼亚语 伊博语 俄语 保加利亚语 僧伽罗语 克罗地亚语 冰岛语 加利西亚语 加泰罗尼亚语 匈牙利语 南非祖鲁语 卡纳达语 印地语 印尼巽他语 印尼爪哇语 印尼语 古吉拉特语 哈萨克语 土耳其语 塔吉克语 塞尔维亚语 塞索托语 威尔士语 孟加拉语 宿务语 尼泊尔语 巴斯克语 布尔语(南非荷兰语) 希伯来语 希腊语 德语 意大利语 意第绪语 拉丁语 拉脱维亚语 挪威语 捷克语 斯洛伐克语 斯洛文尼亚语 斯瓦希里语 旁遮普语 日语 格鲁吉亚语 毛利语 法语 波兰语 波斯尼亚语 波斯语 泰卢固语 泰米尔语 泰语 海地克里奥尔语 爱尔兰语 爱沙尼亚语 瑞典语 白俄罗斯语 立陶宛语 索马里语 约鲁巴语 缅甸语 罗马尼亚语 老挝语 芬兰语 苗语 英语 荷兰语 菲律宾语 葡萄牙语 蒙古语 西班牙语 豪萨语 越南语 阿塞拜疆语 阿尔巴尼亚语 阿拉伯语 韩语 马其顿语 马尔加什语 马拉地语 马拉雅拉姆语 马来语 马耳他语 高棉语 齐切瓦语

 

 

 

文本转语音功能仅限200个字符

 

选项 : 历史 : 反馈 : Donate

关闭