前言

先简单聊聊我个人的理解，我理解的面向对象是思想层面的。Oriented Object，简称OO。与面向对象相对于的编程思想是面向过程。 面向过程比较注重的是功能的实现，像C语言那样，以函数为载体，也是基本单位。所有的代码都是由函数来组织的。 面向对象比较注重的是对象的构建，以类为单位，而把功能[方法]封装在类中，以对象为载体，代码都是以类来组织的。 面向对象三大基本特征分别是封装、集成、多态。由面向对象才引申出类和对象的概念。

类和对象

定义

类是对象的抽象化，它是一个抽象的概念。 对象是类的具体化，它是一个具体的概念。

• 如何知道要定义某个类呢？ 以面向对象的思想去描述客观事物的能力，决定你编写代码的思想。 所以，OO的步骤为： A. 得到一个需求 B. 根据这个需求去找出所涉及到的所有”对象” C. 利用抽象的能力，把找出的这些“对象”进行“归类”[抽象化的过程] D. 利用 Java 的语法把它描述成 xxx.java类型，从而得到这个类。
• 如何定义一个类？ 根据对象拥有的属性和能力来定义一个类型，也可以说，一个类由如下部分组成： A. 这个类拥有什么？也就是属性。 B. 这个类能干什么？也就是方法。

属性[field]

修饰符 数据类型 属性名[ = 初始值]; 从语法上可以看出，属性的定义与变量基本一样，所以，属性也叫实例变量。 如：

 public class A {
    //属性
    private int i;
    private String name;
    //
}  

那么一个类，到底应该定义哪些属性呢？要根据所在对象的上下文来定义。 注：同一个类从不同的视角分析同一个对象，所得到的这个对象属性和功能是不一样的。 如：

 public class Student {
    //属性：拥有什么？ 它是数据[数据结构]的载体
    private String stuNo; //学号
    private String stuName; //姓名
    private char gender; //性别
    private String major; //专业
    //...
    //方法：能干什么？ 它是算法的载体
    //学习
    public void study() {
        //...
    }
    //考试
    public void exam() {
        //...
    }
    //...
}  

注 ：在Java中，只有三种量： A. 局部变量 [Local variable] B. 实例变量[instance variable] C. 类变量,也叫静态属性[class variable] 它们的生命周期大大的不同。 局部变量的生命周期只存在于定义它的那一对大括号中。 实例变量随对象而存在。 类变量随类而存在，只要类加载进JVM,则它就在。

构造方法[constructor]

构造方法是一个特殊的方法，用于类的初始化。当类中没有定义任何的构造方法时，则JVM会自动提供一个默认构造[空参构造]。它有以下特点： A. 没有返回类型。 B. 方法名必须与类名同名。 C. 支持重载。

注 ：构造方法的作用：A. 用来给属性赋值的。B. 满足创建对象的语法要求。 注 ：对象创建的过程： 1).申请堆空间 [对象就创建好了] 2).给属性赋初始值 3).调用构造方法[给属性赋值] 如：

 	Student s1 = new Student();
	int i;  

对象是存放在堆空间中的”数据”。 引用是指向堆空间中对象的地址。

我们必须通过引用去操作对象，而不能直接操作对象。 没有引用，对象是不会单独存在的。

注 ：一个没有初始化的对象是不能使用的，否则会出现NullPointerException【空指针异常】。

如：

   Student s1 = null;
  s1.study();// 会出现异常  

注 ： 一个对象可以有多个引用指向它。 一个引用在某一时间最多指向一个对象。

this关键字

1.表示当前对象[current object]。本质就是”创建好的对象的地址”! 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代“当前对象”。 2.用来同类的调用其它的构造方法。

注 ：this不能用于 static 方法中。

static关键字

static是Java中表示修饰符的关键字，根据他所修饰的目标不同进行分析。

修饰方法

被修饰的方法就是静态方法，它将来是通过ClassName来访问的。如：

 public class A {
  //
  public static int add(int a, int b) { 
    return a + b;
  }
  //
  public static void main(String args[]){
    int sum = A.add(1,2);
    System.out.println(sum);//3
  }
}  

修饰属性

被修饰的属性就是静态属性，也叫 类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。它是属于“类的”，而不是属于“对象的”。

 public class B {
	private int i; //实例变量
	private static int j; //类变量,所有此类的实例共享

	//...
	public void setI(int i) { this.i = i;}
	public int getI() { return this.i; }
	//
	public static void setJ(int j1) { j=j1;}
	public static int getJ(){ return j; }
	//
	public static void main(String args[]){
		B b1 = new B();
		b1.setI(100);
		B b2 = new B();
		b2.setI(200);
		b2.setJ(500);

		System.out.println(B.getJ()); //500
		System.out.println(B.getJ()); //500
	}
}  

• 静态方法不能直接访问非静态成员。
• 非静态方法可以直接访问静态成员。
• 静态方法中不能使用this。 因为静态成员和非静态成员在初始化的时机上是不一样的。 有了静态成员后，创建对象的过程如下：
• 在类加载[classload]时：首先。给静态属性申请空间[永久区]其次，给静态属性赋初始值。最后调用静态代码块[如果有的话]
• 在创建类的实例时，总是按如下4步递归地创建父类对象：为类的非静态属性申请堆空间给非静态属性赋初始值调用普通代码块[如果有的话]调用构造方法

注 ：类加载只会发生1次。

修饰代码块

静态代码块只有类加载时被执行1次。 所以，它适合用来执行： A. 加载一些大的、固定的资源，如文件 B. 建立连接池 … 注 ：静态代码块不能直接访问非静态属性。

修饰内部类

被修饰的类称为静态内部类。 如：

 public class Outer {
	//属性
	....
	//
	static class Inner {
		//属性

		//方法
		...
	}
	//方法
}  

final关键字

final和static都是表示修饰符的关键字，所以我们也根据他所修饰的目标不同进行分析。

修饰局部变量，就称为常量。

如：

 final int I = 9; //局部常量  

修饰属性，就成了常量属性。

如：

 public class A {
	//public final int I = 9; //属性
	public static final int I = 9; //属性
	//...
}  

注 ：常量属性往往都是再加static修饰。

修饰方法，就成了最终方法。

如：

 public class A {
	//...
	public final void f() {
		//....
	}	
}  

注 ：final方法是不能被子类重写的。

修饰类，就成了最终类。

如：

 public final class B {
	//..
}

public class C extends B { //报错
	//..
}  

注 ：final类是不能被继承的。

问： abstract 和final能共同修饰一个类吗？ 答：不能。

问：abstract和private、static能共同修饰一个方法吗？ 答：不能。

结束语

欢迎关注公众号「Java全栈笔记」，获取更多Java知识。