java编程入门1 static、this、super、final关键字

1.static关键字

static关键字用来修饰类的成员，如成员变量，成员方法及代码块，分别称为静态成员变量、静态成员方法、静态代码块。

1.静态成员变量

静态成员变量与一般成员变量的区别

1）归属及内存分配空间不同

一般成员变量是属于对象的，即创建对象后，一般成员变量才存在，且其内存分配空间与各自的对象相关

静态成员变量是属于类的，即在装载类定义代码时，系统为静态成员变量分配独自的存储空间，所有属于这个类的对象共享这个存储空间

2）调用方法不同

一般成员对象通过创建对象调用

静态成员变量可以通过创建对象调用以及通过类调用

调用格式：类名.成员变量名； 对象名.成员变量名；

2.静态成员方法

1） 同静态成员变量，静态成员方法属于类，即在装载了类定义代码后，可通过类调用静态成员方法，当然也可以通过创建对象调用。

调用格式：类名.成员方法([实参列表])； 对象名.成员方法([实参列表])；

2）静态方法只能直接处理静态域，但可以通过创建对象处理非静态域

3）main方法为静态方法 public static void main(String[] args)

3.静态代码块

1）使用一对大括号括起来的若干行代码称为一个代码块，用static关键字修饰的代码块称为静态代码块

在类被加载时，会按照static块的顺序来执行每个static块，由于类只加载一次，因此静态代码块也只被执行一次。

2）在程序中。通常使用静态代码块对类的成员变量进行初始化

public class Demo1 {
    static int cnt;
    String name;
    Demo1(){
        cnt++;
    }
    void print1() {
        System.out.println("调用成员方法");
        System.out.println(cnt);
        System.out.println(name);
    }
    static void print2() {
        System.out.println("调用静态成员方法");
        System.out.println(cnt);
    }
    static void print3() {
        System.out.println("调用静态成员方法");
        Demo1 ob=new Demo1();
        ob.name="zhangshan";
        ob.print1();
    }
    static {
        System.out.println("Demo1静态代码块");
        cnt=0;
    }
}
class Test{
    public static void main(String[] args) {
        System.out.println(Demo1.cnt);
        Demo1.print3();
        Demo1 d=new Demo1();
        d.name="lisi";
        d.print1();
    }
    static {
        System.out.println("调用Test静态代码块");
    }
}

2.this关键字

this关键字：

1）this.a 调用成员变量

2）this.f(); 调用成员方法

3）this(); 调用本类中的构造方法

public class Demo {
    int length,width,height;
    public void Area() {
        int area=2*(this.height*this.length+this.height*this.width+this.length*this.width);
        //1.在类的方法中调用对象成员时，系统默认在对象成员前加上this，表示访问的是当前对象的成员。
        System.out.println(area);
    }
    public Demo(int length,int width,int height) {
        this.height=height;
        this.length=length;
        this.width=width;
        //2.通过this关键字可以明确访问类成员，解决与局部变量名字冲突问题
    }
    public Demo() {
        this.height=1;
        this.length=1;
        this.width=1;
    }
    public Demo(int length) {
        //3.当使用在构造方法中调用另一个构造方法时，可通过执行"this([实参1，实参2....])"来实现

        //使用"this([实参1，实参2....])"调用构造方法时，需注意以下几点
        //a."this([实参1，实参2....])"只能在构造方法中使用，且只能用于显式调用构造方法
        //b."this([实参1，实参2....])"只能放在构造函数中的第一行，且只能出现一次
        //c.不能在一个类的两个构造方法中使用this相互调用

        this();
        this.length=length;
    }
}
class Test{
    public static void main(String[] args) {
        Demo d=new Demo(5);
        d.Area();
    }
}

3.super关键字

super关键字

1.可通过super关键字来访问父类的成员变量，成员方法，构造方法

1) super.成员变量

2) super.成员方法([实参1，实参2...])

3) super() 父类的构造方法

2.创建子类对象时，系统自动调用父类和子类的构造方法，

调用的顺序是，首先根据构造方法调用匹配机制，在子类中找到相匹配的构造方法并调用，该构造方法可能是系统自动生成，也可能是自定义的；接着进入该构造方法体，调用父类的构造方法；然后返回执行子类构造方法的后续语句；

调用父类构造方法的机制是，如果子类构造方法中没有显示调用或显示调用语句为super(),则调用父类不带参数的构造方法；如果子类构造方法中有显示调用语句super(实参1，实参2),则根据调用匹配机制，调用相匹配的父类构造方法。

public class Demo1 {
    public Demo1(){
        System.out.println("父类的构造方法");
    }
    int a=10;
    public void f() {
        System.out.println("父类的成员方法");
    }   
}

class Demo2 extends Demo1{
    public Demo2() {
        System.out.println("子类构造方法");
    }
    public void f() {
        System.out.println(super.a);
        super.f();
    }
}
class Test {
    public static void main(String[] args) {
        Demo2 ob=new Demo2();
        ob.f();
    }
}

4.final关键字

final 关键字

final关键字可以修饰类，方法，和变量(包括成员变量和局部变量)

1.final关键字修饰类

final关键字修饰类表示该类不能被继承,

final类中的所有成员方法都被隐式的指定为final方法

2.final关键字修饰方法

在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final

类的private方法会隐式的被指定为final方法

3.final关键字修饰变量

对于一个final变量,如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改.

如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象

final参数问题

java参数传递采用的是值传递，对于基本类型的变量，相当于直接将变量进行了拷贝,所以即使没有final修饰的情况下，在方法内部改变了变量i的值也不会影响方法外的i。

对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响。

public class Test {
    public static void main(String[] args)  {
        MyClass obj=new MyClass();
        TestClass ob=new TestClass();
        obj.f(ob);
        System.out.println("main函数:"+ob.i);
    }
}
class TestClass{
    int i=0;
}
class MyClass{
    public void f(TestClass ob1) {
        ob1.i++;
        ob1=new TestClass(); //将形参ob1指向新的对象，形参改变对实参没有影响。
        System.out.println("MyClass类中:"+ob1.i);
    }
}