this,final super,static关键字

this关键字

this调用构造方法:

在之前学习方法之间调用时,可以通过方法名进行调用。可是针对构造方法,无法通过构造方法名来相互调用。

构造方法之间的调用,可以通过this关键字来完成。

|------构造方法调用格式:

this(参数列表);

|------构造方法的调用:

package com.oracle.demo01;
public class student {
    private String name;
    private int age;
    public student(){
        //this()在构造方法中调用本类的其他构造方法
        //this()必须放在本构造方法的第一行
        this("zhangsan",18);
    }
    public student (String name,int age){
        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.demo01;

public class test {

    public static void main(String[] args) {
        student s=new student();
        System.out.println(s.getName()+"..."+s.getAge());

    }

}

结果:

super关键字:

子父类中构造方法的调用:

在创建子类对象时,父类的构造方法会先执行,因为子类中所有构造方法的第一行有默认的隐式super();语句。

格式:

调用本类中的构造方法

this(实参列表);

调用父类中的空参数构造方法

super();

调用父类中的有参数构造方法

super(实参列表);

子类继承了父类的内容,所以创建对象时,必须要先看父类是如何对其内容进行初始化的

package com.oracle.demo02;
public class person {
    private String name;
    private int age;
    public person() {
        super();
    }
    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.demo02;
public class gongren extends person{
    public gongren(String name ,int age){
        super(name,age);
    }
}
package com.oracle.demo02;
public class student extends person{
    public student(String name,int age){
    super(name,age);
    }
}
package com.oracle.demo02;
public class test {
    public static void main(String[] args) {
        student s =new student("小明",2);
        System.out.println(s.getName()+"..."+s.getAge());
        gongren w=new gongren("小红",28);
        System.out.println(w.getName()+"..."+w.getAge());
    }
}

结果为:

子类构造方法执行时中,调用了父类构造方法,这说明,子类构造方法中有一句super()。

子类会继承父类中的内容,所以子类在初始化时,必须先到父类中去执行父类的初始化动作。这样,才可以使用父类中的内容。

当父类中没有空参数构造方法时,子类的构造方法必须有显示的super语句,指定要访问的父类有参数构造方法。

注意:

类中的构造方法默认第一行都有隐式的super()语句,在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化,也可以给自己的子类对象初始化。

如果默认的隐式super()语句在父类中没有对应的构造方法,那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

final关键字

final的概念:

继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。需要使用到一个关键字final,final的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量。不能修饰构造方法。

final的特点:

final修饰类不可以被继承,但是可以继承其他类。

class Yy {}

final class Fu extends Yy{} //可以继承Yy类

class Zi extends Fu{} //不能继承Fu类

final修饰的方法不可以被子类重写,但父类中没有被final修饰方法,子类重写后可以加final。

class Fu {

// final修饰的方法,不可以被覆盖,但可以继承使用

    public final void method1(){}

    public void method2(){}

}

class Zi extends Fu {

//重写method2方法

public final void method2(){}

}

final修饰的变量称为常量,这些变量只能赋值一次。而且终身不变。

final int i = 20;
i = 30; //赋值报错,final修饰的变量只能赋值一次

引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。

final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p,所记录的地址值不能改变
p.name = "小明";//可以更改p对象中name属性值

p对象中的name或age可以更改

修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)

class Demo {
//直接赋值
final int m = 100;
//final修饰的成员变量,需要在创建对象前赋值,否则报错。
final int n;
public Demo(){
//可以在创建对象时所调用的构造方法中,为变量n赋值
n = 2016;
}
}

例子

package com.oracle.demo03;
//final修饰类(太监类)
//不能被继承,但能继承其他类
public final class fu {
}
package com.oracle.demo03;
public class fu2 {
    public final void xiuche(){
        System.out.println("失传");
    }
    public void maiche(){
        System.out.println("卖车");
    }
}
package com.oracle.demo03;
public class zi extends fu2{
    /*public final void xiuche(){
        System.out.println("失传");
    }*/
    public final void maiche(){
        System.out.println("卖车");
    }
}
package com.oracle.demo03;
public class zi2 {
    public void eat(){
        final int i=3;
        fu2 f=new fu2();
        f =null;
    }
}
package com.oracle.demo03;
//被final修饰的成员变量没有系统默认初始值
public class zi3 {
    final String name;
    public zi3(String name){
        this.name=name;
    }
}

static关键字

static概念:

当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,这个方法没有访问到对象的特有数据时,方法创建这个对象有些多余。我们可以通过static关键字来实现。static它是静态修饰符,一般用来修饰类中的成员。

static特点:

1,被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)

class Demo {
    public static int num = 100;
}
class Test {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
        d1.num = 200;
        System.out.println(d1.num); //结果为200
        System.out.println(d2.num); //结果为200
    }
}

2.被static修饰的成员可以并且建议通过类名直接访问。

访问静态成员的格式:

类名.静态成员变量名

类名.静态成员方法名(参数)

对象名.静态成员变量名      ------不建议使用该方式,会出现警告

对象名.静态成员方法名(参数) ------不建议使用该方式,会出现警告
class Demo {
    //静态成员变量
    public static int num = 100;
    //静态方法
    public static void method(){
        System.out.println("静态方法");
    }
}
class Test {
    public static void main(String[] args) {
        System.out.println(Demo.num);
        Demo.method();
    }
}

static注意事项:

1.静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。

class Demo {
    //成员变量
    public int num = 100;
    //静态方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

2.同一个类中,静态成员只能访问静态成员

class Demo {
    //成员变量
    public int num = 100;
    //静态方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

3.main方法为静态方法仅仅为程序执行入口,它不属于任何一个对象,可以定义在任意类中。

4.多态调用方法中,编译看=左边,父类有,编译成功,父类没有,编译失败

运行,静态方法,运行父类中的静态方法,

运行,非静态方法,运行子类的重写方法

成员变量,编译运行全是父类

定义静态常量

开发中,我们想在类中定义一个静态常量,通常使用public static final修饰的变量来完成定义。此时变量名用全部大写,多个单词使用下划线连接。

定义格式:

public static final 数据类型 变量名 = 值;

如下演示:

class School {

public static final String SCHOOL_NAME = "北京大学";

public static void method(){

System.out.println("一个静态方法");

}

}

当我们想使用类的静态成员时,不需要创建对象,直接使用类名来访问即可。

System.out.println(Company.SCHOOL_NAME);

Company.method(); // 调用一个静态方法

注意:

接口中的每个成员变量都默认使用public static final修饰。

所有接口中的成员变量已是静态常量,由于接口没有构造方法,所以必须显示赋值。可以直接用接口名访问。

interface Inter {
public static final int COUNT = 100;
}

访问接口中的静态变量

Inter.COUNT

=======================================================================================================================================

package com.oracle.demo04;
public class demo {
//静态只能调用静态,不能调用非静态
//非静态可以访问静态
    //成员变量不管静态不静态都看父类成员变量
    public static void main(String[] args) {
        demo d=new demo();
        d.eat();
    }
    public void eat(){

    }
}
package com.oracle.demo04;
public class student {
    String name;
    int age;
    static String schoolname;
}
package com.oracle.demo04;
public class test {
    public static void main(String[] args) {
        student s=new student();
        s.name="xiaohong";
        student.schoolname="beijingdaxue";
        student s2=new student();
        s2.name="xiaoming";
        student.schoolname="qinghuadaxue";
    System.out.println(student.schoolname+"..."+student.schoolname);
    }

}

结果:

原文地址:https://www.cnblogs.com/q-1234/p/9712241.html

时间: 2024-10-09 20:38:11

this,final super,static关键字的相关文章

Java基础之final、static关键字

一.前言 关于这两个关键字,应该是在开发工作中比较常见的,使用频率上来说也比较高.接口中.常量.静态方法等等.但是,使用频繁却不代表一定是能够清晰明白的了解,能说出个子丑演卯来.下面,对这两个关键字的常见用法做点总结记录,方便之后的回顾以及突击知识点. 二.关键字 final final,一如字面意思 “最终的”,大体在 Java 中表示 “不可变的”.可用来修饰类.方法.方法参数以及变量. 1.修饰类 final 在修饰类的时候,代表的是此类不能被继承.也就是说如果一个类确定不会被继承使用,则

final、static关键字

Final 定义  在实际开发中,有些方法不能直接覆盖掉,不想让子类重写父类的方法,那么就引出final关键字(可以修饰类,变量,成员方法). 基本用法 final可以修饰类,但是该类不能被继承,但可以继承其他类. final可以修饰变量(成员变量,局部变量),(两种方法:一直接赋值,二用构造方法)但是该变量此时变成了一个常量. final可以修饰成员方法,但是该方法不能被重写,但可以被继承. final 修饰局部变量时,可以先定义使用时再赋值. final 不能修饰接口.抽象类.抽象方法. f

Java中final和static关键字总结

1.final: final关键字可用于类.方法.变量前. final修饰的类不可被继承,例如java.lang.Math就是一个 final类,不可被继承. final修饰变量,在显示初始化后不可改变变量值,用于常量定义.如果final变量是引用变量,则不可以改变它的引用对象,但可以改变对象的数据(属性). final修饰的方法不可被重写. 错误案例) package com.sp; public final class Fish {        final String name = "鱼

self ,super , static关键字

1.self关键字  自己的   代表当前对象和当前类的. a.如果self是在对象方法中使用的话,self就代表当前的对象. self其实是一个指针,是当前对象的地址. 有什么用? 对象方法中,是可以声明一个和属性名字相同的局部变量的. 在对象方法里,如果你直接使用这个名字相同的这个变量,得到的值是这个局部变量的值. 如果我就是要拿到属性的值呢?就是用self关键字去执向. 如果在对象方法中,要去调用当前对象的其他的对象方法,就使用self去调用. b. self也是可以用在类方法中的,sel

Java final、static 关键字

问:谈谈 Java 中 final.finally.finalize 的区别?   答:这道题其实没有任何意义,无非就是考察开发者有没有区分这几个关键字的含义,仅仅关联是因为长得像而已. final 是一个修饰符,如果一个类被声明为 final 则其不能再派生出新的子类,所以一个类不能既被声明为 abstract 又被声明为 final 的:将变量或方法声明为 final 可以保证它们在使用中不被改变(对于对象变量来说其引用不可变,即不能再指向其他的对象,但是对象的值可变),被声明为 final

Java基础之final和static关键字

一.final        根据程序上下文环境,它可以修饰非抽象类.非抽象类成员方法和变量. final类不能被继承,没有子类,final类中的方法默认是final的.        final方法不能被子类的方法覆盖,但可以被继承.        final成员变量表示常量,只能被赋值一次,赋值后值不再改变.        final不能用于修饰构造方法.        注意:父类的private成员方法是不能被子类方法覆盖的,因此private类型的方法默认是final类型的. 1.fin

final和static关键字的个人认识

final fianl关键字可以修饰类.方法和变量. a. 修饰类 final修饰的类,该类没有子类,该类不能被继承. b. 修饰方法 final可以修饰方法.final修饰的方法不能被重写. c. 修饰变量 final修饰的变量,是一个常量,且只能被赋值 一次,可以是成员变量和局部变量. static a. static用于修饰成员,可以是成员变量和成员方法. b. 被static修饰后的成员,可以直接被类调用. 类名.静态成员 c. 随着类的加载而加载,随着类的消失而消失.类一加载,就有静态

java 中final和static关键字说明

final fianl关键字可以修饰类.方法和变量. a. 修饰类 final修饰的类,该类没有子类,该类不能被继承. b. 修饰方法 final可以修饰方法.final修饰的方法不能被重写. c. 修饰变量 final修饰的变量,是一个常量,且只能被赋值 一次,可以是成员变量和局部变量. static a. static用于修饰成员,可以是成员变量和成员方法. b. 被static修饰后的成员,可以直接被类调用. 类名.静态成员 c. 随着类的加载而加载,随着类的消失而消失.类一加载,就有静态

第九天(上) final和static关键字

继承的出现提高了代码的复用性,方便开发,是多态的前提,但随之而来的也有问题,有些累在描述后不想被继承,或者里面的方法功能时固定的,不想让子类重写,可子类继承之后又可以重写该怎么办呢 这个时候就需要一个关键字final  意为 最终的 不可变的 Final是一个比较强的修饰符,可以用来修饰类,类的成员,以及方法 Final修饰类 在类的前面加上final Final类不可以被继承,但可以继承其他类,是个太监.其成员方法也默认为final的,但成员变量是可以改变的 在使用final修饰类的时候,要注