首页 > 编程语言 > 详细

java的关键字 this、super、final、static、

时间:2018-09-25 17:09:44      阅读:137      评论:0      收藏:0      [点我收藏+]

1、this关键字
(1)成员变量和局部变量同名
可以在成员变量名前面加上this.来区别成员变量和局部变量

package com.oracle.demo03;

public class person {
            private  String name;
            private int age;
            public person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
            
}

(2)调用构造方法
在构造方法中调用本类的其他构造方法this()【根据参数列表区分】
必须放在本构造方法的第一行

package com.oracle.demo01;

public class Demo02 {
    private String name;
    private  int age;
    public Demo02(String name,int age){
        this.name = name;
        this.age = age;
    }
    public  Demo02(){
        //在构造方法中调用本类的其他构造方法this()
        //必须放在本构造方法的第一行
        this("zhangsan",18);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}

测试类:

package com.oracle.demo01;

public class Demo01 {
     public static void main(String[] args) {
         Demo02   d = new Demo02();
         System.out.println(d.getName()+".."+d.getAge());
    }
}

2、super关键字
(1)子父类中构造方法的调用
隐式语句:super(); 【默认】
调用父类中的有参数构造方法:super(实参列表);
子类会继承父类中的内容,所以子类在初始化时,必须先到父类中去执行父类的初始化动作。
当父类中没有空参数构造方法时,子类的构造方法必须有显示的super语句,指定要访问的父类有参数构造方法。

package com.oracle.demo02;

public class person {
    public  person(String name,int age){
            System.out.println("父类构造");
    }
}
package com.oracle.demo02;

public class teacher  extends person{
            String name;
            int age;
            public teacher(){
                super("zhangsan",12);
                /*this("lisi",12);*/   
                System.out.println("子类构造");
            }
            public teacher(String name,int age){
                super( name, age);
            }
}
package com.oracle.demo02;

public class test {
        public static void main(String[] args) {
            teacher   t = new teacher(); 
        }
}

效果如下:

技术分享图片

 


(2)子类对象创建过程的细节
只要是构造方法默认第一行都是super();
如果第一行调用了this()构造方法,显示的super()语句可以间接调用。

package com.oracle.demo02;

public class person {
    public  person(String name,int age){
            System.out.println("父类构造");
    }
}
package com.oracle.demo02;

public class teacher  extends person{
            String name;
            int age;
            public teacher(){
                //super("zhangsan",12);
                this("lisi",12);
                System.out.println("子类构造");
            }
            public teacher(String name,int age){
                super( name, age);
            }
}

 

package com.oracle.demo02;

public class test {
        public static void main(String[] args) {
            teacher   t = new teacher(); 
        }
}

效果如下:

技术分享图片

(3)super应用

package com.oracle.demo03;

public class person {
            private  String name;
            private int age;
            public person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
            
}
package com.oracle.demo03;

public class student extends person{

    public student(String name, int age) {
        super(name, age);    
    }
        
}
package com.oracle.demo03;

public class worker extends person{

    public worker(String name, int age) {
        super(name, age);        
    }
}
package com.oracle.demo03;

public class ceshi {
            public static void main(String[] args) {
                student  s = new student("小明",2);
                System.out.println(s.getAge()+s.getName());
                worker w = new worker("小红",80);
                System.out.println(w.getAge()+w.getName());
            }
}

效果如下:

技术分享图片

 

3、final关键字
(1)final修饰的类不能被继承,但可以继承其他类

package com.oracle.demo04;
//final 修饰类(太监类)
//不能被继承,但可以继承其他类
public final class fu extends Object{
        
}

技术分享图片

(2)final修饰的成员方法不能重写,但是不修饰的重写的可以加final修饰

package com.oracle.demo04;

public class fu2 {
        //被final修饰的方法
        public final void  xiuche(){
            System.out.println("修车");
        }
        public  void maiche(){
            System.out.println("卖车");
        }
}
package com.oracle.demo04;

public class son extends fu2{
    /*public  void  xiuche(){
        System.out.println("车");
    }*/
    public final void maiche(){
        System.out.println("车");
    }
}

(3)被final修饰的成员变量没有系统默认初始值,需要在创建对象前赋值,否则报错.

package com.oracle.demo04;

public class zi2 {
        public  void eat(){
            final int i = 2;
            //i = 2;  哪怕是原来的值也不行。
        }
}

注意:

技术分享图片

 


(4)被final修饰的局部变量是常量,不能改变,如果是引用数据类型,可以对其属性进行修改。

 

package com.oracle.demo04;

public class fu2 {
        String name;
        //被final修饰的方法
        public final void  xiuche(){
            System.out.println("修车");
        }
        public  void maiche(){
            System.out.println("卖车");
        }
}

 

package com.oracle.demo04;

public class zi2 {
        public  void eat(){
            final  fu2 f= new fu2();
            //f=null;
            f.name = "lisi";
        }
}

4、static关键字
(1)被static修饰的成员变量属于类,不属于这个类的某个对象【清华大学】

package com.oracle.demo05;

public class student {
        String name;
        int age;
        static String schollname;
}
package com.oracle.demo05;

import javax.print.attribute.Size2DSyntax;

public class test {
    public static void main(String[] args) {
        student   s = new student();
        s.name = "小红";
        s.schollname = "北京大学";
        student   s1 = new student();        
        s1.name = "小明";
        s1.schollname = "清华大学";
        System.out.println(s.schollname+s1.schollname);
    }
}

效果如下:

技术分享图片

 


(2)静态成员只能调用静态成员,不能调用非静态成员,非静态成员可以调用静态成员。

package com.oracle.demo05;

public class ceshi {
     
    static  int  a = 1;
     int  b = 2;
    public static void main(String[] args) {
        //静态成员可以调用静态成员方法
        eat();
        //静态成员不可以调用非静态成员方法
        //study();
        /*Cannot make a static reference to 
        the non-static method study() from the 
         type ceshi*/
        //静态成员方法可以调用静态成员变量
        System.out.println(a);
        //静态成员方法不可以调用非静态成员变量
        //System.out.println(b);
    }
    public static void eat(){
          
    }
    public  void study(){
        //非静态成员方法可以调用静态成员方法
          eat();
          //非静态成员方法可以调用静态成员变量
          System.out.println(a);
    }
}

(3)不能使用this/super【this、super属于对象,而静态属于类】

 

 

技术分享图片

(4)定义静态常量:public static final  修饰变量 【接口】 

 

java的关键字 this、super、final、static、

原文:https://www.cnblogs.com/scw123/p/9700346.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!