面向对象的思想：
面向对象和面向过程的区别：
面向对象的三大特点：
封装，继承，多态
封装性：
继承性：
多态性：
类与对象：
在面向对象中，为了做到让程序对事物的描述与事物在现实中形态保持一致，面向对象思想中提出了两个概念，即类和对象，在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分配内存空间，如下所示：
使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();
}
}
输出：
虽然程序是成功通过编译的，但是年龄为负值，在现实生活中显然是不符合常规的，因此为了避免这种错误的发生，我们在设计类的时候，应该对成员变量的访问做出一些限定，不允许外界访问，这就需要实现类的封装。
实现封装的方法：
在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