面向对象的思想：
面向对象和面向过程的区别：
面向对象的三大特点：
封装，继承，多态
封装性：
继承性：
多态性：
类与对象：
在面向对象中，为了做到让程序对事物的描述与事物在现实中形态保持一致，面向对象思想中提出了两个概念，即类和对象，在Java程序中类和对象是最基本，最重要的单元，类表示某类群体的一些基本特征抽象，对象表示一个个具体的事物。
例如：在现实生活中，学生就可以表示为一个类，而一个具体的学生，就可以称为对象，一个具体的学生会有自己的姓名和年龄等信息，这些信息在面对对象的概念中称为属性，学生可以看书和打篮球，而看书和打篮球这些行为在类中就成为方法。
他们之间的关系如下图所示：
上图所示中：
学生表示一个类，而小明，李华，大军则是学生这个类型的对象。
类用于描述多个对象的共同特征，它是对象的模板，例如小明，李华，大军的共同特征都是学生。
对象用于描述现实中的个体，它是类的实例，例如学生小明，李华，大军。
对象是根据类创建的，一个类可以对应多个对象，如上图所示，学生这个类创建了3个对象。
类的定义：
在面向对象的思想中最核心的就是对象，而创建对象的前提是需要定义一个类，类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素，所有的Java程序都是基于类的。
定义格式如下：
class 类名{
成员变量； //用于描述对象的特征-----对象的属性
成员方法； //描述对象的行为------对象的行为
}
举例：
class Student{ String name;//定义String类型的变量name int age;//定义int类型的变量age String sex;//定义String类型的变量sex //定义read()方法 void read() { System.out.println("大家好，我是"+name+",我在看书!"); } }
局部变量和成员变量的区别：
在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。
定义的局部变量和成员变量同名，这种情况也是被允许的，此时，在方法中通过变量访问到的是局部变量，而并非成员变量。
举例：
class Student{ int age=30; void read() { int age=50;//age此时被定义在方法中，因此是局部变量 System.out.println("大家好，我"+age+"岁了,我在看书"); } }
此时不仅在方法read中有age这个变量，在该方法之外也有age这个变量，因此，如果此时，另外一个程序调用read()方法时，输出的值为50，而不是30
对象的创建：
在Java程序中，可以使用new关键字创建对象，具体格式如下：
类名 对象名称 =null；
对象名称=new 类名();
上述对象的创建过程为两个步骤，其实，也可以简化为一步，具体格式如下:
类名 对象名称=new 类名(）；
例如，我们现在创建一个Student类的实例对象，实例代码如下：
Student stu=new Student();//stu是Student类型的一个变量
//运算符"="是将新创建的Student对象地址赋值给变量stu,变量stu引用的对象简称为stu对象
对象的使用：
class Student { String name;//属性----名字 void read() { System.out.println("大家好，我是" + name + ",我在看书！"); } public class Test { public static void main(String[] args) { Student stu = new Student();//创建并实例化对象 } } }
上述实例中，使用new关键字创建的对象是在堆内存分配空间，stu对象的内存分配如下图所示：
对象的使用：
当我们创建Student对象后，可以使用对象访问类中的某个属性或方法，对象属性和方法的访问通过“.”运算符实现。
语法格式如下：
对象名称.属性名
对象名称.方法名
举例：
class Student { String name;//属性----名字 void read() { System.out.println("大家好，我是" + name + ",我在看书！"); } } public class student1 { public static void main(String[] args) { //创建并实例化对象 Student stu1 = new Student(); Student stu2=new Student(); stu1.name="小明";//给name属性赋值 stu1.read();//实例stu1访问read方法 stu2.name="小张"; stu2.read();//实例stu2访问read方法 } }
输出：
大家好，我是小明,我在看书！ 大家好，我是小张,我在看书！
此时内存变化如下所示：
对象的引用传递：
类属于引用数据类型，引用数据类型就是指在内存空间可以同时被多个栈内存引用。
举例：
class Student { String name;//属性----名字 int age;//属性----年龄 void read() { System.out.println("大家好，我是" + name + ",年龄"+age); } } public class student1 { public static void main(String[] args) { Student stu1 = new Student();//创建并实例化对象 Student stu2=null;//创建对象stu2，但不对齐进行实例化 stu2=stu1;//stu1对象为stu2对象分配使用权 stu1.name="小明"; stu1.age=20; stu1.read(); stu2.age=18; stu2.read(); } }
输出：
大家好，我是小明,年龄20 大家好，我是小明,年龄18
下面我们对上述代码进行分析：
Student stu1 = new Student();//创建并实例化对象 Student stu2=null;//创建对象stu2，但不对齐进行实例化
为对象stu1分配内存空间，如下所示：
stu2=stu1;//stu1对象为stu2对象分配使用权
使stu1和stu2指向同一块内存：
stu1对象为属性赋值：
通过stu2修改age的值：
注：一个栈内存只能指向一个堆内存，如果想要再指向其他堆内存空间，就必须先断开已有的指向才能分配新的空间。
访问控制：
指针类，成员方法和属性，Java提供了四种访问控制权限。分别是private，default，protected和public。
这四种访问权限按级别由小到大依次排列：
private（当前类访问级别）：
private属于私有访问权限，用于修饰类的属性和方法，类的成员一旦使用了private关键字修饰，则该成员只能在本类中进行访问。
default：
如果一个类中的属性或方法没有任何的访问权限说明，则该属性或方法就是默认的访问权限，默认的访问权限可以被本包中的其他类访问，但是不能被其他包的类访问。
protected：
属于受保护的访问权限，一个类中的成员使用了protected访问权限，则只能被本包及不同包的子类访问。
public：
public属于公共访问权限，如果一个类中的成员使用了public访问权限，则该成员可以在所有的类中被访问，不管是否在统一包中。
通过下述图表更能直观的显示这几种访问控制：
举例：
public class student1 { public static void main(String[] args) { } public int a;//a可以被所有类进行访问 protected boolean b;//可以被所有子类及本包的类使用 void cc () {//未申明访问控制，因此为默认default-----能在本类使用 System.out.println("包访问权限"); } private class InnerClass {//访问控制为private----只能在本类中进行使用 } }
局部变量是没有访问权限控制的，因为局部成员只在其所在作用域起作用，不可能被其他类访问到。
举例：
如果一个Java源文件中定义的所有类都没有用public修饰，那么这个Java源文件的文件名可以是一切合法的文件名，如果源文件中定义了一个public修饰的类，那么这个源文件的文件名必须与public修饰的类名相同。
封装：
类的封装是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，而是通过该类提供的方法实现对内部信息的操作访问。
实现封装的原因：
在Java面向对象的思想中，封装是指一种将抽象性函数式接口的实现细节部分包装,隐藏起来的方法，封装可以被认为是一个保护屏障，防止本类的代码和数据被外部类定义的代码随机访问。
举例：
class student{ String name; int age; void read() { System.out.println("大家好，我是"+name+",年龄"+age); } } public class student1{ public static void main(String[] args) { student stu=new student(); stu.name="张三"; stu.age=-18;//将年龄赋值为负值 stu.read(); } }
输出：
大家好，我是张三,年龄-18
虽然程序是成功通过编译的，但是年龄为负值，在现实生活中显然是不符合常规的，因此为了避免这种错误的发生，我们在设计类的时候，应该对成员变量的访问做出一些限定，不允许外界访问，这就需要实现类的封装。
实现封装的方法：
在Java中，在定义一个类时，将类中的属性私有化，即使用private关键字修饰类的属性，被私有化的属性只能在类中被访问，如果外界想要访问私有属性，则必须通过setter和getter方法设置和获取属性。
举例：
class student1 { //声明名字和年龄都是私有属性 private String name; private int age; public String getName() { //获取名字 return name; } public void setName(String name) {//设置名字 this.name = name; } public int getAge() {//获取年龄 return age; } public void setAge(int age) {//设置年龄 if (age <= 0) { System.out.println("您输入的年龄有误！"); } else { this.age = age; } } public void read () { System.out.println("大家好，我是" + name + ",年龄" + age); } }
public class Example { public static void main(String[] args) { student1 stu = new student1();//创建实例 //调用方法，传递实参 stu.setName("张三"); stu.setAge(-18); stu.read(); } }
输出：
您输入的年龄有误！//年龄小于0时，提示错误 大家好，我是张三,年龄0
