JAVA基础知识 --- 关键字和构造方法

关键字private

• private关键字特点:
  a.是一个权限修饰符。
  b.可以修饰成员变量和成员方法。
  c.被其修饰的成员只能在本类中被访问，外界无法访问。
• private最常见的应用：
  (1):把成员变量用private修饰。
  (2):提供对应的getXxx()和setXxx()方法。
• 相对应的关键字public：
  也是一个权限修饰符，可以修饰类、成员变量和成员方法，被修饰的成员在任何地方都可以访问
• 案例：演示使用封装来完善一个类

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("苏柳");
        person.setAge(18);
        String name = person.getName();
        System.out.println(name);
        int age = person.getAge();
        System.out.println(age);
    }
}

public class Person {
    String name;
    private int age;    //私有的成员变量，只能在本类中方法，外界无法访问
    //提供get方法，让外界通过get方法，获取成员变量的值
    public String getName() {
        return name;
    }
    //提供set方法，让外界通过set方法给成员变量赋值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

关键字 this

• this的引入：
  当局部变量和成员变量相同的时候,如果不使用this关键字,那么会导致一个问题就是局部变量隐藏了成员变量的问题。
• this关键字特点：
  是当前类的对象引用。
  简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁。
• this的应用场景：
  解决局部变量隐藏成员变量。
• 案例：

ublic class MyTest {
    public static void main(String[] args) {
        A a = new A();
        int num=10;
        a.show(num,a);
        System.out.println(num);    // 10
    }
}

class A{
    int num=100;
    public void show(int num, A a){
        System.out.println(num);   //  10
        System.out.println(a.num);   // 100
        System.out.println(this.num);  //100
        System.out.println(a==this);   // true
    }
}

说明： System.out.println(a.num); 与 System.out.println(this.num); 结果相同

构造方法

• 构造方法概述和作用：
  创建对象,给对象中的成员进行初始化，即在创建对象时，除了使用关键字new 之外 还得借助构造方法，来完成对类的实例化。
• 构造方法格式特点：
  a.方法名与类名相同
  b.没有返回值类型，连void都没有
  c.没有具体的返回值
• 借助空参的构造方法创建对象：

		Student student = new Student();
        student.setName("zhangsan");
        student.setAge(13);
        System.out.println(student.getName());
        System.out.println(student.getAge());

• 借助有参的构造方法创建对象：
  在创建对象的同时，就可以给成员变量赋值

        Student student1 = new Student("wangwu", 25);
        System.out.println(student1.getName());
        System.out.println(student1.getAge());

• 构造方法的重载：
  指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
  即，在类中可以创建多个方法，其具有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同
  eg：

  class A{
  	public void show(int a,int b){
  	}
  	public void show(int a,string b){
  	}
  }
  

• 构造方法注意事项：
  a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
  b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
  注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

public class MyTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setAge(1);
        int age = dog.getAge();
        String name = dog.getName();
        System.out.println("名字"+name+"== 年龄"+age);
        dog.lookDoor();
        dog.show();
        System.out.println("-----------------");
        Dog dog1 = new Dog("小白", 2);
        System.out.println(dog1.getName());
        System.out.println(dog1.getAge());
        dog1.show();
        dog1.lookDoor();
    }
}

public class Dog {
    private String name;
    private int age;

    //提供空参构造，有参构造
    public Dog() {
    }
     public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }

    public void show() {
        System.out.println("姓名" + name + "===年龄：" + this.age);
    }
}

• 给成员变量赋值的两种方式： a.setXxx()方法 。 b.构造方法

创建一个对象的步骤

• 画图演示：说明一个对象的创建过程做了哪些事情 ?

public class MyTest {
    public static void main(String[] args) {
        Student s = new Student("王五", 25);
    }
}

public class Student {
    private String name="张三";
    private int age=10;

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

    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;
    }
    public void show(){
        System.out.println(name+"==="+age);
    }
}

• 步骤:
  (1):加载Student.class文件进内存
  (2):在栈内存为s开辟空间
  (3):在堆内存为学生对象开辟空间
  (4):对学生对象的成员变量进行默认初始化
  (5):对学生对象的成员变量进行显示初始化
  (6):通过构造方法对学生对象的成员变量赋值
  (7):学生对象初始化完毕，把对象地址赋值给s变量

关键字static

• static的引入：我想让某个数据变成共享变量，让这个类的所有对象都能够共享他，可以使用一个关键字static（静态的）， 可以修饰成员变量和成员方法。
• static关键字的特点：
  a:随着类的加载而加载，（随着 .class文件进内存，静态的东西就会加载）
  b:优先于对象存在，
  c:被类的所有对象共享，被static所修饰的成员变量，是一个共享变量，存储在方法区，被类的所有对象所共享。
  d:可以通过类名调用，其实它本身也可以通过对象名调用。
  推荐使用类名调用。静态修饰的内容一般称其为：与类相关的，类成员。
• 案例及其内存图：

public class MyTest {
    public static void main(String[] args) {
        // 被static 所修饰的推荐使用类名直接调用
        //因为静态变量，属于类，所以使用类名直接调用即可
        A.b=500;
        int b = A.b;
        System.out.println(b)；
        A.show();     //静态方法，推荐使用类名直接调用
    }
}

class A{
    double a=100;
    static int b=1000; //共享变量
    public static void show(){
        System.out.println("这是一个静态的show方法");
    }
}

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

A:所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用