1：在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。面向对象的编程思想，力图让程序中对事物的描述与该事物在现实中的形态保持一致。
2：面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一次调用就可以了。面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。
3：（1）封装性：封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。
（2）继承性：继承性主要描述的是类与类之间的关系，通过继承，可以在无需编写原有类的情况下，对原有类的功能进行拓展。继承不仅增强了代码的复用性，提高了开发效率，还为程序的维护补充提供了便利。
（3）多态性：多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类周静具有不同的语义。
4：类和对象。类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。
类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。
对象是根据类创建的，并且一个类可以对应多个对象。
注：在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。
5：在面向对象的思想中，最核心的就是对象。为了在程序中创建对象，首先需要定义一个类。类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性；成员方法用于描述对象的行为，可简称为方法。
6：因为在实例化对象时，Java虚拟机会自动为成员变量进行初始化，针对不同类型的成员变量，Java虚拟机会赋予不同的初始值，如下表：
| 成员变量类型 | 初始值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0F |
| double | 0.0D |
| char | 空字符，‘\u000’ |
| boolean | false |
| 引用数据类型 | null |
7：对象成为垃圾对象的两种情况
（1）：超出作用域；
（2）：在程序运行时，当把变量p1置为null，那么p1所引用的（类）对象就会失去引用，成为垃圾对象。
在Java中，null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象。
8：类的封装：所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰。私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的共有方法，其中包括用于获取属性值的getXxx方法和设置属性值的setXxx方法。
9：构造方法
构造方法是类的一个特殊成员，它会在类实例化对象时被自动调用。
同时满足一下三个条件：
（1）：方法名与类名相同；
（2）：在方法名的前面没有返回值类型的声明；
（3）：在方法中不能有return语句返回一个值，但是可以单独写return语句来作为方法的结束。
10：构造方法的重载
只要每个构造方法的参数类型或参数个数不同即可。
注：（1）：一旦为该类定义了构造方法，系统就不再提供默认的构造方法了。为了避免错误，在一个类中如果定义了有参的构造方法，最好再定义一个无参的构造方法。
（２）：如果构造方法是私有的，不可以被外界调用，也就无法在类的外部创建该类的实例对象。因此。为了实例化对象，构造方法通常会使用public来修饰。
11：this关键字
关键字this指代当前对象，用于在方法中访问对象的其他成员。
this的三种常见方法
（1）：可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题。
class Person{
int age;
public Person(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
}
（2）：通过this关键字调用成员方法
class Person{
public void openMouth(){
...
}
public void speak(){
this.openMouth();
}
}
在上面的speak（）方法中，使用this关键字调用openMouth（）方法。注意，此处的this关键字可以省略不写，也就是上面的代码中，写成“this.openMouth”和“openMouth”，效果是完全一样的。
（3）：构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this([参数1，参数2，…])”的形式来调用其他的构造方法。
class Person{
public Person(){
System.out.println("无参的构造方法被调用了...");
}
public Person(String name){
this(); //调用无参构造方法
System.out.println("有参的构造方法被调用了...")
}
}
public class Example1{
public static void main(String[] args){
Person p = new Person("itcast"); //实例化Person对象
}
}
在使用this调用类的构造方法中，应主义以下几点。
1：只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用；
2：在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。（下面有实例）
3：不能在一个类的两个构造方法中使用this互相调用。（下面有实例）
下面的两段代码是错误的
public Person(){
String name = "小韩";
this(name); //调用有参的构造方法。由于不在第一行，编译出错！
}
class Person{ //互相调用出错
public Person(){
this("小韩"); //调用有参的构造方法
System.out.println("无参的构造方法被调用了...")
}
public Person(String name){
this(); //调用无参的构造方法
System.out.println("有参的构造方法被调用了...")
}
}
12：垃圾回收
Java虚拟机会自动回收垃圾对象所占有的空间。一个对象在成为垃圾后会暂时地保留在内存中，当这样的垃圾堆积到一定程度时，Java虚拟机就会启动垃圾回收器将这些垃圾对象从内存中释放，从而使程序获得更多可用的内存空间。除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用System.gc()方法来通知Java虚拟机立即进行垃圾回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义fianlize()方法来观察对象何时被释放。
13：static关键字（静态变量）
（1）：一个静态变量，可以通过类．变量访问，也可以通过实例对象．变量访问。
（2）：static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译会报错。
public class Student{
public void study(){
static int num = 10; //这行代码是非法的，编译会报错
}
}
（3）：在类中定义的方法前面加上static关键字，成这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。
注：在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。
（4）：静态代码块：在Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化。
public class Ex1{
//静态代码块
static{
System.out.println("测试类的静态代码块执行了");
}
public static void mian(String[] args){
Person p1 = new Person();
Person p2 = new Person();
}
}
class Person{
//静态代码块
static {
System.out.println("Person静态代码块执行了");
}
}
结果为下面的内容：
注：在该方法中创建了两个Person对象，但在两次实例化对象的过程中，静态代码块中的内容只输出了一次，这就说明静态代码块在类第一次使用时才会被加载，并且只会加载一次。
14：内部类：在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置、修饰符和定义的方式可分为成员内部类、静态内部类、方法内部类。
在一个类中除了可以定义成员变量、成员方法外，还可以定义类，这样的类被称作成员内部类。在成员内部类中，可以访问外部类的所有成员。
class Outer{
private int num=4;
public void test(){
Inner inner=new Inner();
inner.show();
}
private class Inner{
void show(){
System.out.println("num="+num);
}
}
}
public class Ex5 {
public static void main(String[] args){
//分为两种情况
//Outer.Inner inner= new Outer().new Inner(); //内部类不能声明为私有
//inner.show();
Outer outer=new Outer(); //内部类可以声明为私有
outer.test();
}
}
如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象，创建内部类对象的具体语法格式如下：
外部类名．内部类名 变量名 ＝ new 外部类名（）．new 内部类名（）；
需要注意的是，如果内部类被声明为私有，外界将无法访问。因为私有的话，在另一类中不能访问。
思考题
1：什么是对象？什么是类？类和对象有什么关系？
1）对象：对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象具有状态，一个对象用数据值来描述它的状态。对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中。
2）类：具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。
3）类与对象的关系就如模具和铸件的关系，类的实例化的结果就是对象，而对对象的抽象就是类，类描述了一组有相同特性（属性）和相同行为的对象。
2：请简述this关键字的应用。
（1）：可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题。
（2）：通过this关键字调用成员方法
（3）：调用构造方法
详细看上文第11条。
- 文章是新手所写，难免会有些知识点不全或者错误，还望发现错误的朋友，留言批评改正。