黑马程序员——java基础之this与静态

——- android培训、java培训、期待与您交流！ ———-

Java中支持成员变量和局部变量是可以重复的。
    变量的使用规则：就近原则。

    当成员变量和局部变量同时存在时，我们如果直接使用变量，则使用的是局部变量。
    如果我要是成员变量：this.成员变量;

    访问成员变量时，需要使用“对象.成员变量”;

this关键字：
    指的是当前对象。谁调用，这个this就是谁。  
    在我们类的方法中，隐藏了一个对象，这个对象就是this。谁调用这个方法，这个this就是谁。

class Student {
    int age = 18;
    public void show(){
        int age = 20;
        System.out.println("局部变量"+age);
        System.out.println("成员变量"+this.age);
    }

    public void method(){
        System.out.println(this);
    }
}
class ThisDemo {
    public static void main(String[] args) {
        Student s = new Student();
        //s.show();
        System.out.println(s);
        s.method();
    }
}

this关键字的作用：
    使用属性：this.属性; //当局部变量和成员变量重名时，使用this来调用成员变量。
    使用方法：this.方法();  //this在使用方法时，可以省略。
    调用构造方法：

class Student {
    int age = 18;
    public void show(){
        //System.out.println("成员变量"+this.age);
        method();
        System.out.println("show");

    }

    public void method(){
        System.out.println("method");
    }
}
class ThisDemo2 {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

this可以调用构造方法：
    this在调用构造方法的时候的格式：this(参数);
    注意事项：
        1.this调用构造方法时，必须放在构造方法中的第一行。
        2.构造方法不能自己调用自己。
        3.不能循环相互调用。

class Student {
    public Student(){
        this("测试");
        //this();  //构造方法不能自己调用自己。
        System.out.println("无参构造方法");           
    }

    public Student(String s){
        //this();
        System.out.println("有参构造方法");
    }

}
class ThisDemo3 {
    public static void main(String[] args) {
        Student s = new Student();
    }
}

static:静态。
    当我们对象的属性的值是相同内容的时候，我们就可以把我们这个属性变为static修饰的属性，
    这样，我们这个属性就会让所有对象的这个属性公用一块内存。

class Student {
    String name;
    static String className;

    public Student(){}

    public Student(String name,String className){
        this.name = name;
        this.className = className;
    }
}
class StaticDemo {
    public static void main(String[] args) {
        //创建第一个学生
        Student s1 = new Student("小名","13");
        //创建第二个学生
        //Student s2 = new Student("小花","13");
        Student s2 = new Student();
        s2.name = "小花";
        System.out.println(s2.className);
        s2.className = "基础班";
        System.out.println(s2.className);
        System.out.println(s1.className);
    }
}

属性被static修饰之后，不仅可以使用“对象.属性”来调用，还可以使用“类名.属性”来调用
    静态属性可以直接通过“类名.属性”来调用。

    static可以修饰属性，也可以修饰方法。
        当static修饰成员时，我们可以使用“类名.成员”来调用。

static的优点：
    1.修饰属性时，类的所有对象公用这一个属性。节省了内存空间。
    2.访问很方便，不需要再创建对象了。
static的缺点：
    1.生命周期太长。
    2.访问有限制。

static在使用的时候的注意事项：
    1.静态方法不能使用非静态变量。
    2.非静态方法可以访问静态变量。
    3.静态方法中不能使用this。
    4.局部变量是不允许是静态的。

class Student {
    String name;
    static String className;

    public Student(){}

    public Student(String name,String className){
        this.name = name;
        this.className = className;
    }

    //静态方法
    public static void test(){

        System.out.println("test方法");
    }

    //非静态方法
    public void method(){
        System.out.println(className);
    }
}

class StaticDemo2 {
    public static void main(String[] args) {
        /*
        //创建第一个学生
        Student s1 = new Student("小明","13");

        //System.out.println(s1.name);
        System.out.println(s1.className);
        System.out.println(Student.className);


        Student s1 = new Student("小明","13");
        s1.test();
        */

        Student.test();
    }
}

静态代码块：静态的构造代码块。
    静态代码块，只在类的加载的时候运行。
    问题：
        静态代码块和静态方法一样，不能使用非静态变量和this关

class StaticCode {
    String name;
    {
        this.name = "nihao";
        System.out.println("我是构造代码块");
    }

    static{
        //this.name = "nihao";
        System.out.println("我是静态代码块");
    }
}
class StaticCodeDemo {
    public static void main(String[] args) {
        StaticCode s1 = new StaticCode();
        StaticCode s2 = new StaticCode();
        StaticCode s3 = new StaticCode();
        StaticCode s4 = new StaticCode();
    }
}

API:指的是Java工程师给我们写好的那些工具类（查API，指的就是去看API文档，说明书。）
API寻找类：
    1.左上角点击“显示”
    2.在三个选项卡中找“索引”
    3.在方框框中写上你要找的类。
    4.找到之后双击，就打开了，
看API：
    1.看该类的结构。
        如果是lang包下，则直接可以使用。其他包需要导入。
    2.看下边一大段文字。这段文字是这个类的说明性文字。
    3.看版本。版本说明我们这个类在哪个版本之后可以使用。
    4.字段摘要：指的就是类的属性。
    5.构造方法：创建对象。
    6.方法摘要：就是普通方法，就是我们将要使用的方法。
        左边：
            数据类型：指的就是方法返回值的类型。
            static：静态，指的是该方法是静态方法。
        右边：
            valueOf(boolean b) 
            名字，也就是valueOf，就是方法的方法名。
            （）里边的内容，就是参数。
            还有一段文字，就是方法的说明。

总结

静态成员：类加载的时候就出现。
非静态成员：对象创建的时候出现。
因为类先出现，所以，静态的成员，一定是先出现的。非静态成员后出现。

先出现的不能使用后出现的。后出现的可以使用先出现的。

静态变量和成员变量的区别：
存储位置：
    静态变量：存储在方法区，和类在一块。
    非静态变量：存储在堆中，和对象在一块
生命周期：
    静态变量：随着类的加载而加载，随着类的消失而消失。
    非静态变量：随着对象的创建而创建，随着对象的消失而消失。
使用：
    静态变量：可以使用"对象.属性"来访问，也可以使用"类名.属性"来访问。
    非静态变量：只能使用"对象.属性"来访问。

多个类之间的相互调用：
类可以作为参数进行传递。
我们学会思考谁是主动方谁是被动方。
    让主动方方法中加上被动方。


this关键字：
可以调用：
    成员变量：this.成员变量; //当成员变量和局部变量重复时，使用“this.成员变量”来调用成员变量。
    成员方法：this.成员方法; //this可以省略。
    构造方法：this(参数);
        注意：
            1.构造方法不能自己调用自己。
            2.必须是放在构造方法的第一行。
            3.构造方法不能循环相互调用。

static关键字：
可以修饰属性和方法。
    修饰成员时，则类的所有对象都共享该成员。
    修饰成员时：可以使用“类名.成员”来访问。

    静态方法不能调用非静态成员。还不能使用this;
    局部变量不能是静态的。

代码块：
局部代码块：方法中。限制变量的使用范围。
构造代码块：类中、方法之外。执行任何构造方法之前，都必须先执行构造代码块。
静态代码块：类中、方法之外。只在类加载的时候执行一次，而且仅仅一次。
文档注释：

API：Java工程师给我们写好的工具类。
Scanner类：获取用户在控制台输入的东西。
创建对象：
    Scanner sc = new Scanner(System.in);
使用：
    nextInt()  获取用户在控制台输入的数字。
    nextLine(); 获取用户在控制台输入的一段文字。
Math类：
操作数学运算的。

Random类：产生随机数。
常用方法：
    nextInt(int n) ;产生一个0-n之间（不包含n）的整数类型随机数。

导入包：
在类上边，加上
import 包名.类名;
比如：Random
import java.util.Random;

——- android培训、java培训、期待与您交流！ ———-