Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。对象有以下特点：

• 对象具有属性和行为。
• 对象具有变化的状态。
• 对象具有唯一性。
• 对象都是某个类别的实例。
• 一切皆为对象，真实世界中的所有事物都可以视为对象。

简单来说，我们自然世界中的每一个个体都是一个对象，而每一个个体又都不一样，有的黑皮肤，有的黄皮肤，有的白皮肤，有的长头发，有的短头发，高矮胖瘦各不相同。
但是因为我们都有相同的一些特性，比如会讲话，有手有脚，有五官，是哺乳动物，正因为我们这些共同点，所以我们共同属于一个种类——人类。人类，就是人的总称，也是相似对象的一种抽象。

我们每一个人都是人类的特例，所以说类的具体表现或者实例就是对象，而对象的抽象就是类。
对象是由类创建的，先有类，才有对象，对象是由类实例化的。

2.1 类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。

我们构造一个Person类来帮助理解

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

	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;
	}

	public void move() {
		System.out.println(this.getName() + "年龄：" + this.getAge() + "正在行动！");
	}
	public void study() {
		System.out.println(this.getName() + "年龄：" + this.getAge() + "正在学习！");
	}
	public void eat() {
		System.out.println(this.getName() + "年龄：" + this.getAge() + "正在吃饭！");
	}
}

我们创建的Person对象,拥有人类的基本特征（属性）：姓名，年龄等，以及基本行为（方法）:行动，学习，吃饭等。

2.2 Java中的类实现包括两个部分：类声明和类体。

2.2.1 类声明
[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}
其中，修饰符public,abstract,final 说明了类的属性，className为类名，superclassName为类的父类的名字，interfaceNameList为类所实现的接口列表。

2.2.2类体

class className{
    [public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
        statements
    }//成员方法
}

成员变量限定词的含义：

• static: 静态变量（类变量）
• final: 常量；transient: 暂时性变量，用于对象存档，用于对象的串行化
• volatile: 贡献变量，用于并发线程的共享

2.3方法的实现也包括两部分内容：方法声明和方法体。
2.3.1方法声明:
方法声明中的限定词的含义：

• static: 类方法，可通过类名直接调用
• abstract: 抽象方法，没有方法体
• final: 方法不能被重写
• native: 集成其它语言的代码
• synchronized: 控制多个并发线程的访问

2.3.2方法体
方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部 变量的作用域在该方法内部。若局部变量与类的成员变量同名，则类的成员变量被隐藏。

2.4构造方法

• 构造方法是一个特殊的方法。Java 中的每个类都有构造方法，用来初始化该类的一个对象。
• 构造方法具有和类名相同的名称，而且不返回任何数据类型。
• 重载经常用于构造方法。
• 构造方法只能由new运算符调用

对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

接下来，我们对使用Person新建一个对象

public static void main(String[] args) {
		Person hunman = new Person("张三", 25);
		hunman.move();
		hunman.study();
		Person.eat();
				
	}

执行结果

张三 年龄:25 正在行动！
张三 年龄:25 正在学习！
吃饭是一个人活下去的基本条件！

类的成员一般有初始化块，构造器，属性，方法，内部类，枚举类。我们对于该对象赋予了名字，年龄的属性，同时他也有了类的具体表现形式，行动，学习等等。
因为对于每个人来说如果不摄入营养就失去了活下去的可能。所以把创建静态方法的eat(),以供所有的类和对象调用。而move(),study()这类不是static的方法，则需要实例化的对象来调用。

  4.1封装
  封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。

 可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

 A.访问修饰符

• private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。

• default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。

• protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。

• public：类中限定为public的成员，可以被所有的类访问。
  
   B.this关键字

• this关键字代表当前对象

• this.属性 调用当前属性

• this.方法 调用当前方法

 C.成员内部类
内部类定义在另一个类里面的类。与之对应,包括内部类的类称为外部类。
1.内部类提供了更好的封装，把内部类的所有信息隐藏在外部类内,不允许同一个包中的类访问该类。
2.内部类的方法可以直接访问外部类的所有数据，包括私有的数据。
3.内部类可分为以下几种:

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

4.2 继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

• Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
  继承实现了代码的复用。
• Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
• 子类不能继承父类中访问权限为private的成员变量和方法。
• 子类可以重写父类的方法，即命名与父类同名的成员变量。
• Java 的继承是单继承，但是可以多重继承

 Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

• 访问父类被隐藏的成员变量，如：super.variable;
• 调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
• 调用父类的构造函数，如：super([paramlist]);

final：
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。

构造器：

• 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

• 如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

  4.3多态
 对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

接下来我们用代码来理解多态的自动转型和强制类型转型

public class PolymorphismTest {
	public static void main(String[] args) {
		show(new Apple());	// 以 Apple 对象调用 show 方法
		show(new WaterMelon());// 以WaterMelon 对象调用 show 方法
		
		Fruit f = new Apple(); //向上转型
		f.eat();// 调用Apple的eat()		
		Apple a = (Apple)f; // 向下转型
		a.eat();// 调用Apple的eat()
	}



public static void show(Fruit a) {
	a.eat();
	if(a instanceof Apple) {
		Apple f = (Apple)a;
		f.look();
	}else if (a instanceof WaterMelon) {
		WaterMelon w = (WaterMelon)a;
		w.look();
	}
}
}
abstract class Fruit {
	abstract void eat();
}

class Apple extends Fruit{
	public void eat() {
		System.out.println("好吃");
	}
	public void look() {
		System.out.println("红色");
	}
}
class WaterMelon extends Fruit{
	public void eat() {
		System.out.println("不好吃");
	}
	public void look() {
		System.out.println("绿色");
	}
}

运行结果：

好吃
红色
不好吃
绿色
好吃
好吃

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

• 编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
• 运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

  4.4重载（Overloading）

• 方法重载是让类以统一的方式处理不同数据类型的手段。
• 一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时* * 通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
  返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

  4.5重写（Overriding）

• 子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
• 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
• 子类函数的访问修饰权限不能低于父类的。