Java 基础第五天

面向对象

this关键字的概述和应用

• 为什么要有this

  当 局部变量 和 成员变量 的 名字相同 的时，如果我们不使用this关键字，那么会导致局部变量隐藏（冲突）了成员变量的问题。

• this关键字特点

  表示当前类的对象引用
  简单记：它就代表当前类的一个对象。谁调用这个方法，该方法的内部的this就代表谁

• this的应用场景

  解决局部变量隐藏（冲突）成员变量

示例代码

class Student {
    private String name;
    private int age;
    private String sex;

    public void setName(String name) {// String name = "张三疯";
        // name = name;//因为有个原则叫就近原则，所以这个时候"张三疯"又赋值给局部变量了，没有赋值到我们希望的成员变量
        this.name = name;// 谁调用这个方法,这个方法中的this就是谁
    }

    public String getName() {
        return name;
    }

    public void show() {
        System.out.println(this.name + " " + age + " " + sex);// 这里隐藏了this
    }
}

// 测试类 ,玩基本类的.创建对象,通过对象调成员
class Demo {
    public static void main(String[] args) {
        // 创建对象
        Student s = new Student();
        // 赋值
        s.setName("张三疯");
        s.setAge(50);
        s.setSex("男");
        s.show();
    }
}

构造方法

对已经做好封装的类（Person为例），由于Person中的属性都被 private 了，外界无法直
接访问属性，如果想设置属性值，就必需使用相应的set和get方法。当创建人对象时，一创建就要明确其姓名和年龄，那该怎么做呢？
- 什么是构造方法？

从字面上理解就是 创建对象 时要 执行 的方法。那么
只要在 new 对象时，知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行 属性赋值 。
构造方法也叫构造器，主要作用是创建对象，给对象中的 成员 进行 初始化

• 构造方法格式
  

  修饰符 构造方法名(参数列表){
  }

- 构造方法的特点

构造方法 没有返回值类型 以及 返回值 （特殊的方法，连void都没有）。不需要写返回值。
因为它是为构建对象的，对象创建完，方法就执行结束。构造方法名称必须和 类名保持一致

示例代码

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Student s = new Student("张三", 18);
        System.out.println(s.getName());
        System.out.println(s.getAge());
    }

}
public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("执行了");
    }
    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;
    }

}

默认构造

• 在没有学习构造方法之前，我们也可以通过new关键字创建对象，并调用相应的方法，同时在描述事物时也没有写构造方法。这是为什么呢？
  

  在之前学习的过程中，描述事物时，并没有显式指定构造方法，当在编译Java文件时，编译器会自动给class文件中添加 默认的构造方法 。如果在描述类时，我们显式指定了构造方法，那么，当在编译Java源文件时，编译器就 `不会再给 class文件中添加 默认构造 方法。

代码格式

class Student {
  //如果没有显式指定构造方法，编译会在编译时自动添加默认的构造方法
  //public Student(){} //空参数的默认构造方法
  }

• 当在描述事物时，要根据描述事物的特点来确定是否需要构造方法：

  当描述的事物在 创建 其对象时就要 明确属性 的值，这时就需要在定义类的时候书写带参数的构造方法。
  若创建对象时不需要明确具体的数据，这时可以不用书写构造方法（不书写也有默认的构造方法）。

• 构造方法的细节：

  一个类中可以有 多个构造方法 ，多个构造方法是以 重载 的形式存在的
  构造方法是可以被 private 修饰的
  作用：其他程序无法创建该类的对象。

示例代码

class Student {
        private int age;
        private String name;

        // 私有无参数的构造方法，即外界不能通过new Person();语句创建本类对象
        private Student() {
        }

        // 多个构造方法是以重载的形式存在
        public Student(int age) {
            this.age = age;

        }

        Person(String name, int age) {
          this.name = name;
          this.age = age;
          }
}

构造方法和一般方法区别（了解）

• 到目前为止，学习两种方法，分别为 构造方法 和 普通方法 ，那么他们之间有什么异同呢？

  1. 构造方法在对象创建时就执行了，而且只执行一次。
  2. 一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。

• 有了构造方法之后可以对对象的属性进行初始化，那么还需要对应的set和get方法吗？

  1. 需要相应的set和get方法，因为对象在创建之后需要修改和访问相应的属性值时，在这 时只能通过set或者get方法来操作。

代码示例

class Demo {
        public static void main(String[] args) {
            // 使用无参构造
            Student s = new Student();
            System.out.println(s.getName());
            System.out.println("---------使用带参构造方法------------------------");
            // 使用带参构造方法
            Student s2 = new Student("学员一");
            System.out.println(s2.getName());
            System.out.println("---------使用带两个参构造方法------------------------");
            // 使用两个带参构造
            Student s3 = new Student("学员二", 18);
            System.out.println(s3.getName() + "---" + s3.getAge());
            // s3 = new Student("学员三",19);
            s3.setAge(19);
            System.out.println(s3.getName() + "---" + s3.getAge());
            // 我们之前通过set方法进行赋值,现在可以通过构造器进行赋值
        }
    }
    class Student {
        private String name;
        private int age;

        // 构造方法的重载
        public Student() {
            System.out.println("哈哈,我是无参构造");
            // this.name = "学员一";
            // 通过构造方法可以为成员变量赋值,也就是对成员变量进行了初始化
        }

        // 这是一个带一个参数的构造
        public Student(String name) {
            this.name = name;
        }

        // 这是带两个参数的构造
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        // 对外提供公共的
        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public int getAge() {
            return age;
        }
    }

构造方法的重载及注意事项

案例演示

构造方法的重载
构造方法注意事项

构造方法注意事项

如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
如果我们给出了构造方法，系统将不再提供默认的无参构造方法。

注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

构造方法的运行特点，在new的时候运行一次 往后就不再运行
给成员变量赋值的两种方式

setXxx()方法
构造方法

static概念

• 当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，如果该方法没有访问到对象的 成员变量 时，为了调用方法而去创建这个对象有些多余。

• 可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？

可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

• 班级里有多个学生，每个学生名字不一样，但是班级是一样的，每次创建一个对象都要给班级开辟空间，有点浪费内存空间，有没有一种好的方式: 让这几个对象共用这个班级？
  

  可以使用static关键字

静态使用

• 多个对象共享一个数据
  

  学生：Student。每个学生都有班级，比如：JF01。
  针对某个成员是被所有对象共享的时候，该成员就可以被静态(static)修饰。

代码示例

class Student {
    String name;
    // String team;
    static String team;// 使用静态，多个对象共享一个team数据

    public void show() {

        System.out.println(name + "-----" + team);
    }
}

class Demo {
    public static void main(String[] args) {
        Student.team = "jf01";

        Student s1 = new Student();
        s1.name = "学生1";
        // s1.team = "jf01";
        s1.show();

        Student s2 = new Student();
        s2.name = "学生1";
        // s2.team = "jf01";
        s2.show();
        // 学生的team属性相对来说是独立的
    }
}

static关键字的特点

• 被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
• static关键字的特点

随着类的加载而加载
优先于对象存在（直接类名调用）
被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
—-某个成员是被所有对象共享的时候，该成员就可以被静态(static)修饰。

举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)
可以通过类名调用
—其实它本身也可以通过对象名调用。
—推荐使用类名调用。

案例演示: static关键字的特点

class Student {
    int age = 20;
    static int age2 = 25;
}

class StudentDemo {
    public static void main(String[] args) {
        // 创建一个学生对象
        // Student s = new Student();
        // System.out.println(s.age);
        // System.out.println(Student.age);//无法从静态上下文中引用非静态 变量 age
        // System.out.println(s.age2);
        System.out.println(Student.age2);
    }
}

静态变量和非静态成员变量的区别

• 按照是否静态的对类成员变量进行分类，可分两种

  静态变量
  实例变量（成员变量）

• 静态修饰成员变量和局部变量区别：

  静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配（优先于对象存在），可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
  实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

• 所以一般在需要实现以下两个功能时使用静态变量：

  在对象之间共享值时
  方便访问变量时

static修饰成员方法

• static 修饰的方法我们称之为静态方法，通过类名对其进行直接调用。由于他在类加载的时候就存在了，它不依赖于任何实例。

• 使用场景：

  因为静态不依赖对象存在，所以一般会用做工具类（直接类名调用）
  如 Math 类的所有方法都是静态 static 的（工具类）。

示例代码

public class StaticDemo {
    public static void iStatic() {
        System.out.println("我是静态的方法，可以通过类名和对象进行调用。");
    }

    public void noStatic() {
        System.out.println("我不是静态方法，只能通过对象调用。");
    }
}

// 静态调用过程
public class Demo {
    public static void main(String[] args) {
        StaticDemo.iStatic();// 静态方法

        StaticDemo sd = new StaticDemo();
        sd.noStatic();// 非静态
    }
}

static的注意事项

• static的注意事项
  

  在静态方法中是没有this关键字的
  如何理解呢?
  —-静态是随着类的加载而加载，this是随着对象的创建而存在。
  —-静态比对象先存在。
  静态方法只能访问静态的成员变量和静态的成员方法
  —-静态只能访问静态,非静态可以访问静态的也可以访问非静态的

案例演示: static的注意事项

public class Demo {
    int a = 10;// 非静态
    static int b = 10;// 静态

    public static void main(String[] args) {
        iStatic();
        System.out.println(b);
        System.out.println(a);// 错误【无法从静态上下文中引用非静态 方法 noStatic()】
        noStatic();// 错误【无法从静态上下文中引用非静态 方法 noStatic()】

    }

    public static void iStatic() {
        System.out.println("我是静态的方法");
    }

    public void noStatic() {
        System.out.println("我不是静态方法");
    }
}

static关键字的特点总结

• 静态可以修饰成员变量、方法、代码块
  
  1. 随着类的加载而加载
  2. 优先于对象存在（直接类名调用）
  3. 静态修饰的属性，被类的所有对象共享
  4. 静态修饰的方法，可以类名直接调用

代码块

• 静态代码块、构造代码块、构造函数执行顺序（了解）
  
  1. 静态代码块，它是随着类的加载而被执行，只要类被加载了就会执行，而且只会加载一 次，主要用于给类进行初始化。
  2. 构造代码块，每创建一个对象时就会执行一次，且优先于构造函数，主要用于初始化不同 对象共性的初始化内容和初始化实例环境。
  3. 构造函数，每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化，而 构造代码是给所有对象进行初始化，作用区域不同。