深度刨析1--类和对象

目录

---

1. 类的定义和使用
2. 对象的构造和初始化
3. 包
4. 代码块
5. 内部类
6. 访问修饰限定符

---

1.类的定义和使用

1.1.如何定义一个类？

class 加类名；定义类名：大驼峰

1.2.如何使用类？

类中有成员变量(也叫字段或属性)和成员方法

成员变量定义在类中，方法的外边

idea改主类名：鼠标点住这个类，右击选择refactor --> rename

 1.3.如何通过一个类实例化一个对象？

如何访问实例化出来的对象的成员和方法？

访问变量：类对象的引用加上点号访问成员：person.成员

访问方法：person.方法

 1.4.实例化对象的位置关系

 a. new的对象在堆上，成员变量在对象里面

b. 类对象的引用在栈上，属于引用类型（--类似数组）

---

2.对象的构造和初始化

2.1.如何初始化对象

通过前面知识点的学习知道，在 Java 方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象： 

 需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。通过上述例子发现两个问题：

1. 每次对象创建好后调用 SetDate 方法设置具体日期，比较麻烦，那对象该如何初始化？

       

2. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

2.2.默认初始化

上面第二个问题：为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

 2.3.就地初始化（不建议）

 在声明成员变量时，就直接给出了初始值。

  

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

2.4.对象的构造

构造方法：public 加类名  --  对对象中的成员进行初始化，并不负责给对象开辟空间。

看下面这段代码：无参的构造方法

     new Person();这里其实就是调用Person的无参构造方法

构造方法：

  idea快捷键生成：1.鼠标右键，选中Generate  2.选中Constructor  3.选择参数个数

1. 名字必须与类名相同

2. 没有返回值类型，设置为void也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，        每个人只能出生一次)

4.构造方法的本质就是来实例化对象的时候调用--a.分配内存    b.调用合适的构造方法

5.当我们写了一个类，没有写构造方法的时候，编译器会默认生成一个不带参数的构造方法

6.当我们写了任何一个构造方法之后，编译器不再为我们提供不带参数的构造方法

7.一个类至少会有1个构造方法，就算你没有写！！！

8.构造方法是没有返回值的方法，方法名和类名是一样的

9.构造方法不止一个，可以有多个，多个构造方法之间，构成了重载（后面会讲述） 

2.5. this

看下面这段代码：有参的构造方法

class Person {
    //1、属性[成员变量]：定义在类当中  方法的外边的
    public String name;
    public int age;
    public String sex;

    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
   //@Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person("曹操",20,"男");
        System.out.println(person);
    }
}

刨析this关键字

1.代表当前对象的引用（person）

   Person person = new Person();

2.当参数和成员名字冲突的时候，可以区别开来

3.this本质来说，可以看作是一个隐式的参数，且是第一个参数

4.建议以后写代码都把this加上（形参部分可不加）

5.this只能在"成员方法"中使用

6.在成员方法中，this只能引用当前对象，不能再引用其他对象，具有final属性

7.this的用法: a. this.data -> 访问成员变量    b. this.func(); ->访问方法    c. this(); ->调用本类中其他的构造方法

8.this可以用来调用本类中的其他构造方法(只能在构造方法当中使用)--前提:必须放到第一行!!!,而且,只能在当前构造方法中,调用一个this

 9.this不能形成环-->不能在两个构造方法中互相调用对方

   很明显下面代码报错了！

2.6.类对象的引用放在输出语句中

        1.类中有toString方法，就调用自己的toString方法，没有就输出地址（库里面自带的toString方法）

        2.toString方法的快捷键引出：鼠标右击选中Generate--> toString

2.7.static

        1.static修饰的成员变量，一般是通过类名访问；也可以创建对象通过对象来访问(不建议)；在类里边也可以直接访问。

   a.类名访问：

   b.创建对象访问：

 c.类里边直接访问：

 注意：

        1.平时我们我们实例化对象的时候，如果赋null给对象的引用，再用此引用去调用其成员和方法会报一个空指针异常

 2.但是如果这里是访问静态成员和方法，则不会；

    很显然下面这段代码没有报错，原因是：person不指向任何对象，而name也不属于哪个对象，      但是这种方法不建议使用。

 2.静态的成员变量和静态的成员方法，都不依赖于对象，因为他们是类变量；而非静态的成员变量，是依赖于对象的。

a.普通的成员方法中，是可以使用静态的成员变量的，但不能定义静态的变量
  b.静态的成员方法中没有隐藏的this引用参数，因此不能访问非静态的成员

---

3.包（简述）

1.为什么有包这个东西？

帮你组织类，帮你分批量管理类，使得我们在使用代码的时候不会过于冗余

那我们该如何建一个包呢？

公司里边一般是将域名倒过来，将其设为包名，并且包名习惯性都用小写

例如：www.baidu.com --> com.baidu.www/com.baidu.demo1

注意：平时我们所说的导包，是导入包层次下的JAVA类，import是不能导入一个指定的包（文件夹）

---

4.代码块（简述）

代码块分为四种：实例代码块、静态代码块、本地代码块、同步代码块

学类和对象这一块目前只会用到前两种，

两种代码块的执行顺序为：静态代码块>实例代码块>构造方法

实例>构造：从字节码角度来看，是把实例代码块当中的内容，拷贝到了构造方法之前

静态代码块：

1.当一个类实例化多个对象时，静态代码块只执行一次

2.当static变量被多次定义时，会根据定义的顺序进行覆盖，一般输出最后一次赋值的那个

class Student {
    public String name;
    private int age;
    private double score;
    public static String classes;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("调用带有3个参数的构造方法！");
    }

    {
        this.name = "小李";
        this.age = 19;
        this.score = 88;
        System.out.println("实例代码块，优先于构造方法执行！一般用来初始化实例成员变量");
    }

    static {
        classes = "Java1班";
        System.out.println("静态代码块！一般用于初始化静态的数据成员");
    }
    static {
        classes = "104Java2班";
        System.out.println("静态代码块ssssssssss！一般用于初始化静态的数据成员");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ",classes="+ classes +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student animal = new Student("小明",12,89);
        System.out.println(animal);
        System.out.println("==================");
        Student aniaml1 = new Student("小张",13,69);
        System.out.println(aniaml1);
    }
}

 运行结果：

从运行结果可以清晰的看出当一个类实例化多个对象时，代码的执行顺序为：先将静态代码块执行完，再依次执行自己的实例代码块和构造方法；此外，输出静态成员变量classes的值是第二次赋的值。

---

5.内部类

内部类这一块主要讲述两个内容：1.如何生成XXX内部类对象；2.如何访问XXX的成员

5.1.内部类主要分为三种：实例内部类、静态内部类、匿名内部类；

实例内部类：

1.生成实例内部类对象：（实例内部类对象 必须在 先有外部类对象 的前提下才能创建）

2.在实例内部类中如何访问自己的成员？直接访问（实例内部内中访问成员不区分静态和非静态） 

3.如何在实例内部类当中访问外部类成员？

不重名时：

 

4.在外部类中如何拿到实例内部类中的成员变量？

   突然意识到：实例内部类中 不仅包含了自己的this，而且包含了 外部类的this

5.实例内部类当中不能定义静态的成员变量，如果要定义，只能是编译的时候确定的值

   如：必须是由static final 修饰的 --> public static final int data = 10

6.实例内部类当中，如果有成员变量和外部类的成员变量重名了?怎么办?

   优先访问自己的！

   访问外部成员：

   访问实例内部类成员：

 静态内部类：

1.如何实例化静态内部类

  很明显可以看到静态内部类再实例化对象的时候，不需要外部类对象 所以静态内部类使用的频率    会比较多

2.静态内部类 中 访问外部类成员（不创建对象的情况下，因为静态内部类只能访问外部类中的静     态方法，所以不考虑重名的情况）

  a.访问静态成员：直接访问

 b.访问非静态成员：提供外部类对象

 3.外部内 中 访问静态内部类 

   a.访问静态成员：静态内部类名访问

   b.访问非静态成员，创建静态内部类对象访问

字节码：实例/静态内部类，经过编译之后会生成独立的字节码文件，命名格式为:外部类名称 $ 内                部类名称.class --> OuterClass $ Innerclass

---

6.访问修饰限定符

java中总共有以下4中修饰限定符：private、default(什么都不加)、protected、public

 这些修饰符既可以限定类中成员的可见性，也可以控制类的可见性

但要注意的是，成员变量和成员方法可以被这四种限定符修饰，而类只能有两种权限：public和default（默认权限）

什么时候用什么权限限定符根据业务需求，并不用死记一般什么情况用什么限定符。

本篇已完！