一、面向对象程序设计（OOP）
（1）面向对象的程序设计具有3个基本特征：封装、继承和多态。
（2）面向对象的程序是由对象组成的。
（3）JAVA是完全面向对象的。
二、对象（object）
某种事物的抽象功能。抽象包括数据抽象和过程抽象两个方面：
（1）数据抽象就是定义对象的属性；
（2）过程抽象就是定义对象的操作（行为）。
面向对象的程序设计强调把数据（属性）和操作（行为）结合成一个密不可分的系统单位（即对象），对象的外部只需要知道它做什么，而不必知道它如何做。
对象的3个主要特性：
（1）对象的行为（behavior）——可以对对象施加哪些操作，或可以对对象施加哪些方法？
（2）对象的状态（state）——当施加那些方法时，对象如何响应？
（3）对象标识（identity）——如何辨别具有相同行为与状态的不同对象？
三、类（class）
类是构造对象的模板或蓝图。类是JAVA语言的核心，JAVA的一切类型都是类，所有的语句都必须位于类内。
封装（encapsulation，有时称为数据隐藏）是面向对象的主要特性。封装是把客观事物抽象并封装成对象，即将数据成员、属性、方法和事件等集合在一个整体内。通过访问控制，还可以隐藏内部成员，只允许可信的对象访问或操作自己的数据或方法。对象中的数据称为实例域（instance field），操纵数据的过程称为方法（Method）。
实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。封装给对象赋予了“黑盒”特征，这是提高重用性和可靠性的关键。意味着一个类可以全面地改变存储数据的方式，只要依旧使用同样的方法操作数据，其他对象就不会知道或介意所发生的变化。
在JAVA中，Object是所有类的父类。
类是一个数据结构，类定义数据类型的数据（字段）和行为（方法）。由类构造（construct）对象的过程称为创建类的实例（instance）。
类修饰符：用于定义类的可访问性等信息（public、abstract|final、strictfp）。
四、创建和使用对象：
1、对象的创建和使用
类是抽象的，要使用类定义的功能必须实例化类，即创建类的对象。
new得的对象都放在堆上。
对象的初始化方式（4种）：
1、提供一系列的get()、set()方法；
package practise.classAndObject;
/**
*get()set()方法对象初始化
*/
class Person {
private int age;
private String name;
private String sex;
/**生成的set()、get()、toStrign()方法*/
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void sleep() {
System.out.println("Person.sleep()");
}
public void eat() {
System.out.println("Person.eat()");
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
public class TestOne {
public static void main(String[] args) {
Person person = new Person();//实例化一个对象
person.setName("张三");
person.setAge(12);
person.setSex("man");
System.out.println(person);
person.toString();
}
}
package practise.classAndObject;
/**
* 类和对象：
* JAVA是面向对象的语言，面向对象的思想（OOP）
* 面向对象的3大特征：封装、继承、多态
* 封装
*/
/*
*/
class Person_2{
private int age;//数据 未初始化：引用类型默认值NULL，简单类型：int（0）
private String name;//null
private String sex;//null
public void setAge(int age){
this.age = age;
}
public int getAge(int age){
return age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void sleep() {//行为（方法函数）
System.out.println("Person.sleep");
}
public void eat() {
System.out.println("Person.eat");
}
@Override
/**重写Object
* 所有类默认的父类都是Object*/
public String toString() {//默认生成toString方法
return "Person_2{" +
"age=" + age +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
/*
类外通过对象访问数据
*/
public class Test {
public static void main(String[] args) {
Person_2 person = new Person_2();
person.setName("caocao");
person.setAge(13);
person.setSex("man");
/**在JAVA里，new的对象在堆上产生*/
/*Person_2 person = new Person_2();//实例化一个对象
person.age = 12;
person.name = "aa";
person.sex = "man";
person.sleep();
System.out.println(person.toString());
Person_2 person2 = new Person_2();
person2.age = 122;
person2.name = "bb";
person2.sex = "man";
Person_2 person3 = new Person_2();
person.age = 888;
person.name = "cc";
person.sex = "man";*/
}
}
2、通过合适的构造函数：
（1）为对象分配内存；
（2）调用合适的构造函数。
3、静态块初始化；
4、实例块初始化。
初始化顺序：1、静态初始化、2、实例初始化、3、构造函数初始化
四、内部类
（一）内部类是定义在另一个类中的类。
使用内部类的主要原因：
（1）内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据。
（2）内部类可以对同一个包中的其他类隐藏起来。
（3）想要定义一个回调函数且不像编写大量代码时，使用匿名内部类比较便捷。
内部类是一种编译器现象，与虚拟机无关。编译器将会把内部类翻译成$分隔外部类名与内部类名的常规类文件，而虚拟机对此一无所知。