面向对象特殊语法

一、成员变量 VS 局部变量

1、定义的位置不同

成员变量定义在方法体之外，局部变量定义在类体中或者是方法的形式参数

2、内存位置不同

成员变量的值存储在堆上，局部变量的值存储在栈上

3、声明周期不同

成员变量的存储空间随着对象的销毁和销毁（释放），局部变量岁方法栈帧的销毁而销毁

4、初始值不同

局部变量没有被自动赋予默认初值，而成员变量会有默认初值

二、方法引用类型的形式参数

1、实参和形参的值传递方式是复制传递（将实参的值复制一份，赋值给形参）

2、引用类型的变量，在调用方法，和被调用方法中，都属于各自方法中定义的局部变量

3、引用类型的实参和形参的值，在调用方法和被调用方法中各自都有一份，但是，引用类型的实参和形参所指向的数据，是同一份数据

/**
 *  方法引用类型的形式参数
 *
 */


class Demo2{
    int a;
}

public class Demo1 {
    public static void main(String[] args) {
        Demo2 d1 = new Demo2();
        d1.a = 1;
        Demo2 d2 = new Demo2();
        d2.a = 2;

        System.out.println(d1.a);
        System.out.println(d2.a);
        function1(d1, d2);
        System.out.println(d1.a);
        System.out.println(d2.a);

        System.out.println("******************华丽的分割线*************************");
        System.out.println(d1.a);
        System.out.println(d2.a);
        function2(d1, d2);
        System.out.println(d1.a);
        System.out.println(d2.a);
    }

    //方法的参数都是引用类型
    public static void function1(Demo2 d1, Demo2 d2){
        //
        Demo2 temp;
        temp = d1;
        d1 = d2;
        d2 = temp;
        System.out.println("function1：d1.a = " + d1.a + ",d2.a = " + d2.a);

        //当方法被调用执行完后，形式参数随着方法栈帧的销毁而销毁，因此对象的值并没有被交换
    }

    public static void function2(Demo2 d1, Demo2 d2){
        //交换d1 和 d2 这两个引用变量所指向的对象的 成员变量a 的值
        int temp; //局部变量
        temp = d1.a;
        d1.a = d2.a;
        d2.a = temp;
        System.out.println("function2：d1.a = " + d1.a + ",d2.a = " + d2.a);
    }

}

三、构造方法

1、作用——在创建对象的时候，完成对象成员变量的初始化工作（在创建对象的最后一步执行构造方法，对成员变量完成初始化）

2、语法：

（1）、方法名固定，必须和类名相同

（2）、方法声明中，没有返回值类型这一项

（3）、其他和普通的方法定义类似

3、注意事项：

（1）、构造方法可以重载

a、重载条件和普通方法重载条件相同

b、可以根据new类名（实参列表）中的实参列表指明创建某对象时所使用的构造方法

（2）、如果没有定义任何构造函数，则JVM会自动帮我们添加一个默认构造函数，否则不会

（3）、构造方法的执行时机：创建对象的最后一步，JVM用来初始化对象中成员变量的值

package com.cskaoyan.Demo;

public class constructorDemo{
    public static void main(String [] args) {
        ConstructorClass constructor1 = new ConstructorClass();
        ConstructorClass constructor2 = new ConstructorClass("zhangsan");
    }

}

class ConstructorClass{
    // 成员变量
    String name;
    int age;
    boolean isMale;
    int sno;

    //无参构造函数
    public ConstructorClass(){

        System.out.println("无参构造方法：");
        System.out.println("name——" + name + ", age——" + age + ", isMale——" + isMale + ", sno——" + sno);
    }

    // 一参数构造方法
    public ConstructorClass(String nameValue){

        name = nameValue;

        System.out.println("一参构造方法");
        System.out.println("name——" + name + ", age——" + age + ", isMale——" + isMale + ", sno——" + sno);
    }

    // 四参构造方法
    public ConstructorClass(String nameValue, int ageValue, boolean isMaleValue, int snoValue){

        name = nameValue;
        age = ageValue;
        isMale = isMaleValue;
        sno = snoValue;

        System.out.println("四参构造方法");
        System.out.println("name——" + name + ", age——" + age + ", isMale——" + isMale + ", sno——" + sno);
    }


}

四、this关键字

1、表示当前引用对象

2、如何确定this指的是哪个对象？

（1）、如果this出现在构造方法中，指的是正在创建的那个对象

（2）、如果this出现在成员方法中，因为成员方法总是以对象名.的方式访问，使用对象访问该方法，this就指的是哪个对象

3、this的作用

（1）、解决成员变量的隐藏问题

（2）、访问对象的成员变量和成员方法

（3）、访问对象的构造方法

4、成员变量的隐藏问题

（1）、方法中定义了和类中成员变量同名的局部变量

（2）、在方法体中，通过同名变量的变量名来访问变量值，我们只能访问到方法体中的那个局部同名变量的值，而访问不到同名成员变量的值

（3）、在方法体中，就好像同名成员变量被同名局部变量给隐藏起来了

解决方法：

成员变量的隐藏，问题的解决？——可以通过给成员变量的变量名前加一个用来区分成员变量的前缀——this

package com.cskaoyan.Demo;

public class thisDemo {

    public static void main(String[] args) {

        String name = "Lisa";
        Student s1 =  new Student(name);
        System.out.println(s1.name);

        Student s2 = new Student("Jennie");
        System.out.println("name——" + s2.name + ", age——" + s2.age + ", isMale——" + s2.isMale + ", sno——" + s2.sno);

        Student s3 = new Student("Jennie", 25);
        System.out.println("name——" + s3.name + ", age——" + s3.age + ", isMale——" + s3.isMale + ", sno——" + s3.sno);


    }

}

class Student{
    // 成员变量
    String name;
    int age;
    boolean isMale;
    int sno;

    // 定义无参构造方法
    public Student(){
		// this调用构造方法，必须处在构造方法的第一条语句的位置
        this("未知", -1, true, -1);
    }

    // 一参构造方法
    public Student(String name){
        this.name = name;
    }

    // 2参构造方法
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    //四参构造方法
    public Student(String name, int age, boolean isMale, int sno){
        this.name = name;
        this.age = age;
        this.isMale = isMale;
        this.sno = sno;
    }


}

五、static关键字

1、static关键字：可以修饰成员变量和成员方法

被static修饰的成员变量、成员方法，其是按照严格的面向对象思想，他们已经不是严格意义上的成员（成员变量、成员方法）。但习惯上，我们成static修饰的成员变量为静态成员变量（简称静态变量），称被static修饰的成员方法为静态成员方法（简称静态方法）

2、特点：

（1）、被该类的所有对象所共享（判定是否使用static关键字）

​ a、当static修饰了成员变量，该成员变量的值就不再存储在对象中了，而是单独存储了一份，被类的所有对象所共享

​ b、当static修饰成员方法，该方法被当前类的所有对象共享

当前类对象.方法（和普通成员方法从共享的角度，几乎没有太大区别）

（2）、可以直接通过类名访问static修饰的成员变量和成员方法

​

（3）随着类的加载而加载：

​ a、static 修饰的是成员变量，类加载时分配存储空间，并赋予默认初值

​ b、static修饰成员方法，类加载完毕，就可以通过类名访问

（4）、优先于对象而存在（不依赖于对象而存在）

3、注意事项：

（1）、静态方法中不能访问非静态成员变量和非静态成员方法(反之可以)

​ a、无法访问，当前对象的非静态成员变量 或 当前对象的非静态成员方法

​ b、但是，在静态方法中，可以访我们子集new出来的对象的非静态成员变量或非静态成员方法

（2）、静态方法中不能使用this

（3）、不管 静态方法还是非静态方法中，都不能使用static关键字

4、被static修饰的成员变量的存储位置——方法区中

5、静态成员 VS 普通成员变量

（1）、所属不同

​ a、静态变量属于类，所有也称类变量

​ b、成员变量属于对象，所有也称为实例变量（对象变量）

（2）、内存中的位置不同

​ a、静态变量存储在方法区中

​ b、成员变量存储在堆内存中

（3）、内存中出现的时间不同

​ a、静态变量随着类的加载而加载，随着类的消失而消失（先出现在内存中）

​ b、成员变量随着对象的创建为存在，随着对象的消失而消失（后出现在内存中）

（4）、访问方式不同

​ a、静态变量可以通过类名调用，也可以通过对象调用

​ b、成员变量只能通过对象名调用

package com.cskaoyan.Demo;

public class staticDemo {
    public static void main(String[] args) {
        // 随着类加载而加载，可以通过类名. 访问静态成员变量、静态成员方法
        System.out.println(StudentInfo.IntStatic);
        System.out.println("********华丽的分割线**********");

        StudentInfo s1 = new StudentInfo();
        StudentInfo s2 = new StudentInfo();

        // 被该类的所有对象所共享,可以通过对象名. 访问
        System.out.println(s1.IntStatic);
        System.out.println(s2.IntStatic);
        System.out.println("********华丽的分割线**********");


        // 直接通过类名访问static修饰的成员变量和成员方法
        System.out.println(StudentInfo.IntStatic);
        StudentInfo.methodStatic();
    }
}

class StudentInfo{
    // 定义成员变量
    String name;
    int age;
    boolean isMale;
    int sno;
    // 定义静态成员变量
    static int IntStatic;


    // 定义静态成员方法
    public static void methodStatic(){
        System.out.println("静态成员函数被调用");
    }

    // 无参构造方法
    public StudentInfo(){}

    //四参构造方法
    public StudentInfo(String name, int age, boolean isMale, int sno){
        this.name = name;
        this.age = age;
        this.isMale = isMale;
        this.sno = sno;
    }

}

六、代码块

1、定义：在Java中，使用{}括起来的代码被称为代码块

2、局部代码块——在方法体中，通常开发中没人用

优点：限定变量生命周期，及早释放，提高内存利用率（这个优点理论上确实存在，但这个优点在现在JVM中的效果微乎其微，甚至可以忽略不计）

我们在开发中，同时还要追求，代码可维护性（包括代码的可读性）

3、构造代码块

（1）、定义位置——定义在方法体之外

（2）、执行时机——每次创建对象的时候，而且先于构造方法执行

（3）、注意事项——如果多个构造代码块，则这多个构造代码块，按照书写的先后顺序执行

4、静态代码块

（1）、定义位置：类中方法体之外，但同时代码块被static关键字修饰

（2）、执行时机：随类加载而执行

（3）、注意事项：

​ a、静态代码块，属于静态上下文，在静态代码块中，不能非静态的成员变量和成员方法

​ b、因为随着类加载而加载，所以在同一个JVM中，只会执行一次

5、同步代码块（多线程的时候学习）

七、package关键字

1、作用：

（1）、类比操作系统中用来组织文件的文件夹，Java语言中，用包来组织类

（2）、包还可以用来解决 类同名的问题 ，不同包下可以存放不同名的类

（3）、Java语言中通过全类名唯一确定一个类，全类名 = 包名 + 类名

2、语法

package关键在后跟包名，且这条语句必须放在Java文件第一条语句的位置

3、包的命名方式 —— 域名反转的方式

4、注意事项：

当一个Java文件中，没有package关键字定义类所做包时，类所属的包为默认包

八、import关键字

1、作用：

（1）、当类体中的使用了与当前类不同包的类名是，编译器编译时因为无法找到该类的定义而失败

（2）、使用import 声明，为编译器题干该类的定义信息

2、语法：

（1）、import语句后根类的全限定名

（2）、类的全限定名是指包名+类名，在Java语言中，包名+类名才能唯一确定一个类

3、注意事项：

（1）、import声明一般紧跟在package声明之后，必须在类声明之前

（2）、Java语言核心包java.lang包中的类将被隐式导入，可以直接使用其中的类

（3）、可以使用import <包名>.*；一次导入一个包下的多个类 ，但是这种方式不会自动嵌套导入子包中的类