1.面向过程和面向对象

首先我们要先明确面向过程和面向对象的定义：

1. 面向过程（C语言）：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

2. 面向对象（C++,C#,Java等）：是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

2.类的定义与使用

类：类是现实世界或思维世界中的实体在计算机中的反映，是抽象的概念合集，表示的是一个共性的产物，类之中定义的是属性和行为（方法）。
对象：对象是具有类 类型的变量
类与对象的关系：类是对象的抽象，而对象是类的具体实例化。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类只有通过对象才可以使用，而在开发之中应该先产生类，再产生对象。

类的定义格式

在Java中定义类时，用到class关键字：

class ClassName {
    field;  //字段（属性）或者成员变量
    method; //行为（成员方法）
}
1
2
3
4

ClassName为类的名字，{ }中为类的主体。
例：定义一个Student类

class Student {
    public String name;//名字
    public int age;//年龄
    public int height;//身高

    public void printProperties() {//打印属性
        System.out.println(name + " 年龄：" + age + " 身高：" + height);
    }
    public void eat() {//打印吃饭的行为
        System.out.println(name + "正在吃饭");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

该学生类定义完成后，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。
注意：

• 类名采用大驼峰定义，方法名采用小驼峰定义
• 一般一个文件中只定义一个类
• main方法所在的类一般要用public修饰
• public修饰的类必须要和文件名相同

3.类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，而类定义完成后，肯定无法直接使用，必须依靠对象，而用类 类型创建对象的过程，就称为类的实例化。
由于类属于引用数据类型，所以对象的产生语法格式（两种）如下：

1. 格式一：声明并实例化对象：

类名称 对象名称 = new 类名称();

2. 格式二：先声明对象，然后实例化对象：

类名称 对象名称 = null；
对象名称 = new 类名称();

引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。
当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性
对象.方法()：表示调用类之中的方法
例：

class Student {
    public String name;//名字
    public int age;//年龄
    public int height;//身高

    public void printProperties() {//打印属性
        System.out.println(name + " 年龄：" + age + " 身高：" + height);
    }
    public void eat() {//打印吃饭的行为
        System.out.println(name + "正在吃饭");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Student stu = new Student();//声明并实例化对象
        stu.name = "张三";//操作属性内容
        stu.age = 18;
        stu.height = 180;
        stu.printProperties();//调用类中方法
        stu.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果：

以上完成了一个类和对象的操作关系，下面换另一种格式来观察一下：

public class TestDemo {
    public static void main(String[] args) {
        
        //区别在这里
        Student stu = null;//声明对象
        stu = new Student();//实例化对象
        
        stu.name = "张三";//操作属性内容
        stu.age = 18;
        stu.height = 180;
        stu.printProperties();//调用类中方法
        stu.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：

以上两种不同的实例化方式有什么区别呢？
我们从内存的角度分析，首先，给出两种内存空间的概念：

1. 堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间
2. 栈内存：保存的是堆内存的地址，可以简单理解为栈内存保存的对象的名字

任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。
上面两种实例化对象方式的内存表示如下：

两种方式的区别在于①②，第一种声明并实例化的方式实际上就是把①②组合在一起，而第二种先声明然后实例化就是①和②分开执行。
如果没有了实例化对象，结果如何？
如下：

public class TestDemo {
    public static void main(String[] args) {
        Student stu = null;//声明对象
        
        //将实例化对象的语句注释掉
        //stu = new Student();//实例化对象
        
        stu.name = "张三";//操作属性内容
        stu.age = 18;
        stu.height = 180;
        stu.printProperties();//调用类中方法
        stu.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：

此时，程序只声明了Student对象，但并没有实例化Student对象（只有了栈内存，并没有对应的堆内存空间），则程序在编译的时候不会出现任何错误，但是在执行的时候出现了上面的错误信息。这个错误信息表示的是"NullPointerException（空指针异常）"，这种异常只要是引用数据类型都有可能出现。