第16、17课Java零基础面向对象编程实战课堂笔记

简介：
本篇博文主要内容如下：
1. 类
2. 对象
3. 封装
4. 构造器
5. String
一： Java中的类和对象
1. 类的定义和实例化

public class ClasssOps {

public static void main(String[] args) {
        Person p = new Person();
        p.sayHello();
    }
}
class Person {
    String name;
    int age;
    public void sayHello(){
        System.out.println("Name: " + name + " Age: " + age);
    }
}

2.  对象在内存的物理结构：堆中存放的是具体对象实例的内存，栈中存放的是堆空间地址的引用。

3. 对象实例本身必须存在，否则会报空指针错误，例如:

public static void main(String[] args) {
// Person p = new Person();
        Person p = null;
        p.name = "Spark";
        p.age = 6; 
        p.sayHello();
    }

}

错误显示：

Exception in thread "main" java.lang.NullPointerException
    at com.dt.java.ClasssOps.main(ClasssOps.java:8)

特别注意：在所有的情况下，如果你要使用一个对象的功能，首先就必须判断对方存在(也就是说在堆中为对象分配的空间实例)

4.   多个对象实例及其在内存中的物理构造：

    Person p1 = new Person();
        p1.name = "Spark";
        p1.age = 6; 
        p1.sayHello();

        Person p2 = new Person();
        p2.name = "Hadoop";
        p2.age = 10; 
        p2.sayHello();

上述代码在内存中的物理构造如下所示：

二： Java的封装性
1. 封装的核心就是使用”private”来修饰索要隐藏类，属性，方法等；使用private关键字修饰限定后，外界就不能再访问了，否则会报错”not visible”。

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
    The field Person.name is not visible
    The field Person.age is not visible
    The field Person.name is not visible
    The field Person.age is not visible

        at com.dt.java.ClasssOps.main(ClasssOps.java:7)

2.   使用Getter和Setter来访问具体的private级别的属性成员

private String name;
    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;
    }
    private int age;
    public void sayHello(){
        System.out.println("Name: " + name + " Age: " + age);
    }

3.   从最佳实践的角度考虑：
    a)  类中的属性都必须是private的，对属性的具体访问必须通过Getter和Setter来进行的。
    b)  使用了private关键字后只能在类的内部访问。

三： this关键字及类的构造方法
1. This关键字就代表Class本身，可以通过类中的this关键字来访问Class中一切类型的成员(包括private级别的成员)

class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }

四： 匿名对象
1. 实际应用非常广泛，因为很多时候我们使用一个对方可能只是使用一次该对方的方法而已，此时就可以构建匿名对象。

new Person("Hadoop",10).sayHello();

五：String
1. String本身是一个类，可以构建具体的字符串实例对象

        String name = "Java";
        String name1 = new String("Scala");
        System.out.println(name1);

2.  String类是final级别，内容不可修改！！

        public final class String

3.   修改String其实是新生产了String：

        String name = "Java";
        String name1 = new String("Scala");
        System.out.println(name1.hashCode());
        name1 = name1 + name;
        System.out.println(name1.hashCode());

输出结果如下：
79698214
122041448

六： 引用

        Reference r = new Reference();
                r.item = 99;
                System.out.println(r.item);

                invokeItem(r);
                System.out.println(r.item);

        public static void invokeItem(Reference reference){ reference.item = 8888; }

输出结果如下：
99
8888
其内部物理结构如下所示：

七： this关键字解密
1. 通过this关键字可以调用本类的方法和属性，也可以调用类的构造器，同时最为重要的是this代表了当前对象。
2. 使用this调用构造方法。

class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this();
        this.setName(name);
        this.setAge(age);
    }

    public Person(){
        System.out.println("A person Object!!!");
    }

3.  this关键字最为重要的是代表当前的对象实例本身

public Person(String name,int age){
        this();
        this.setName(name);
        this.setAge(age);

        System.out.println(this);
    }
        Person p = new Person("Spark",6);
        System.out.println(p);

输入结果如下：
com.dt.java.Person@15db9742
com.dt.java.Person@15db9742

表明this代表的就是当前对象实例本身。

八： Static关键字解密
1. 如果想让一些属性被所有的对象所共享就需要将其声明为static属性，不需要类的实例就可以直接访问。

class Person {
    private String name;
    private int age;

    static String city = "Beijing";

    System.out.println(Person.city);
}

输入结果如下：
Beijing
2. Static关键字修饰的属性在内存中的物理分布：

3. Static中的数据由于是全局共享的，整个程序运行其间只有一份，所以可以极大的节省内存并提高运行效率。
4. 一个强烈建议，static修饰的内容是全局只读的!!!此时加入final关键字即可让程序无法修改static所限定的属性的内容。

补充说明：在实际Java编程中一般都是多线程编程，如果多条线程修改static变量，此时会引入加锁机制，导致程序变得异常复杂和不稳定。
5. 如果方法前也加入了static关键字进行修饰的话，此时就可以直接调用方便，不需要通过类的实例： public static void main(String[] args) {
6. 可以通过private static做修饰来达到一些奇妙的效果，例如对象实例数量的管理来方面GC和减少内存泄密！！！

    private static int counter = 0;
        public Person(){
        counter++;
    System.out.println("The number of Person instances is :" + counter);
        System.out.println("A person Object!!!");
    }

        new Person();
        new Person();
        new Person();

输出结果如下：
The number of Person instances is :1
A person Object!!!
The number of Person instances is :2
A person Object!!!
The number of Person instances is :3
A person Object!!!

九：main方法解密：public static void main(String[] args) {
1. Main方法的参数详解解析：
a) public: 表示此方法可以被外部调用，其实main是被JVM调用的。
b) Static：表示方法可以由类名称直接调用。
c) void：表明main方法不需要返回值，因为JVM调用了main。
d) main: 系统规定的默认的java执行入口的名称，执行时候每个程序都会去找main方法作为整个程序的执行入口。
e) String args[]: 表示运行时的参数，格式是“类名称Parm1 Param2 Parm3…”
2. 例子说明

    public static void main(String[] args) {
        for(String arg : args){
            System.out.println(arg);
    }

输出结果如下：
Scala
Spark
Java
Hadoop
Kafka
Flink

十：代码块解密
1. 在实际的java编程中，类中所有的不在方法中的内容在该类实例化的时候都会被执行。
2. 代码块是指在方法或者类中用{}封装起来的若干条语句的集合。
3. 最常见和最有用途的是类中使用代码块来初始化类对象的最初状态以及默认配置参数，例如Hadoop的一些系统配置就是通过代码块在对象初始化的时候从系统读入到当前要运行的Application中的。
4. 更加有用途的一个情况是代码块前面加上static关键字，特别适合于获取系统的默认信息或者提前做一些后台的工作。例如Hadoop的一些系统配置就是通过代码块在对象初始化的时候从系统读入当前要运行的Application中的。

十一： java中的内存空间解密
1. 在java中内存空间主要分为4个部分：
a) 栈内存空间：基本变量以及保存引用来指向堆内存空间的地址等。
b) 堆内存空间：保存每个对象具体的属性内存。
c) Static数据区域：保存Static关键字修饰的属性。
d) 全局代码块：保存所有方法的定义。

课程笔记来源：