Java中this、static、super、final

this

class Person
{
    public String _name;
    public int _age;
    public Person()  //无参构造
    {
        System.out.println("Person()");
    }
    public Person(String name)                          
    {
        this._name=name;
        System.out.println("Person(String name)");
    }
    public Person(String name,int age)
    {
        this(name); //调Peson(String name)构造方法
        //this._name=name;
        this._age=age;
        System.out.println("Person(String name,int age)");
    }
}
 
public class Construtor
{
    public static void main(String[] args)
    {
        //Person p1=new Person();  //当没有写构造函数时，系统会自动生成一个无参构造,当写了构造函数，系统不会自动生成无参构造
        //Person p2=new Person("pick");
        Person p3=new Person("pick",11);  //Person(String name) Person(String name,int age)
    }
}

表示调用本类属性：只要在类中访问类的属性一定要加上this关键字
表示调用本类方法：
调用普通方法
this.方法名（参数）
当有类的继承关系时，表示本类方法一定要加上this关键字；
调用构造方法

this调用构造方法必须放在构造方法首行,this(参数)
this调用构造方法不允许成环;
this表示当前对象，并不是当前对象的地址
super
super用于方法
super用于构造方法

class Person
{
    private String name;
    public Person(String name)
    {
        this.name=name;
    }
    
}
class Student extends Person
{
    private int num;
    public Student(String name,int num)
    {
        super(name); //调父类有参构造，必须写super(参数)
        this.num=num;
    }
    // public Student(int num)  //调父类无参构造，可以不写super
    // {
    //     this.num=num;
    // }
}
public class Final
{
    public static void main(String[] args)
    {
        Student s1=new Student(1);
    }
}

当子类调用父类无参构造时，super可写可不写，表示调用父类无参构造；
当子类调用父类有参构造时，super(参数列表),必须写,要告诉编译器当前调用的是哪个有参构造；
子类构造方法中调用父类构造必须放在第一行
this与super不能同时使用（因为两者在构造函数中都必须放第一行）
super用于普通方法
super.方法名（参数）
用于在子类中明确调用父类被覆写的方法，这时super.方法名(参数)可以不放在第一行

class Student extends Person
{
    private int num;
    public void func()
    {
        super.func();
        System.out.println("Student::func()");
    }
}
public class Final
{
    public static void main(String[] args)
    {
        Student s=new Student(); //person::func()  Student::func()
        s.func();
    }
}

super用于属性：
super.属性名表示调用父类中被覆写的属性（权限不能是private，private属性变量在子类中不可见，但是子类继承了父类的私有属性和私有方法）

class Person
{
    public String name="dad"；
}
class Student extends Person
{
    private String name="son";
    public void show()
    {
        System.out.println(super.name);  //父类属性
        System.out.println(this.name); //子类的属性
    }
}

this和super区别：
在这里插入图片描述
static

static属性称为类属性，保存在全局数据区中（方法区-所有对象共享区域），用类名来调用，与类实例化对象无关。
static方法 ---- 类方法（静态方法）
通过类名调用，与对象实例化无关
局部变量不能用static修饰，即在方法中变量（不论是主方法，还是普通方法）
private/static不能用于外部类，即 static class Perosn{},错误

final
在java中，final被称为终结器。

final修饰类

当一个类被final 关键字修饰，表示该类不能拥有子类（该类不允许被继承）；
一旦一个类被final修饰，该类的所有方法都会被默认加上final.(成员变量不会被加上final）。

final修饰方法

当一个方法被final修饰，明确表示该方法不能被覆写;
当一个方法被private修饰后，相当于加了一个final关键字。

final修饰属性

final可以用于成员变量、本地变量，被final修饰的变量变成常量，即值不可以改，类型也不可以改；
被final修饰的成员变量必须在声明时初始化（也可以在构造块或者构造方法中初始化，即final修饰的变量是在对象产生时初始化），否则编译器会报错，并且初始化后无法被修改。而普通类型的成员变量可在构造方法中，也可以在getseter中初始化。

public final int a=100;  //在声明时初始化
public static final int a=5;// 在编译器加载类时初始化
 static final 是全局变量，所有对象共享此变量，并且在类加载时（编译时）初始化，效率较高，通过类名调用

final修饰引用数据类型的变量（值不能被改）

数据类型转换
当使用 +、-、*、/、%、运算操作时，遵循如下规则：
只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型，如果两个操作数中有一个是float类型的，另一个将会被转换为float类型，并且结果也是float类型，如果两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型，否则（操作数为：byte、
short、int 、char），两个数都会被转换成int类型，并且结果也是int类型。但是final修饰的域类型不会发生变化。
请判断下列语句的正确性：

public class Final
{
    public static void main(String[] args)
    {
        byte b1=1,b2=2,b3,b6,b8;
        final byte b4=4,b5=6,b7=9;  //final定义变量值和类型都不能变
        b3=b1+b2; // byte 和byte类型相加，两个数类型都转为int,且结果也是int,从int到byte需要强转，所以该语句错误
        b6=b4+b5; // final byte 和final byte相加类型不会变，结果也是byte，所以该语句正确
        b8=b1+b4; //  byte 和final byte相加，结果是 int ,从int到byte需要强转，所以该语句错误
        b7=b2+b5;  // b7是final修饰，只不可以改，所以该语句错误
        System.out.println(b6); //10
    }
}

Java中this、static、super、final

猜你喜欢