什么是面向对象思想
物以类聚，给事物分类的思维模式
一些种事物可能有共同的特征，相同的构造，但是他们的属性值可能不同
给这种事物分类就是面向对象思想
**例如：**人是一个类
那么男人和女人就是人这个类的分支
在具体到一个人例如给一个人起个名字：张三
这个人就有了名字叫张三
再给张三一个性别：男
那么这个张三就是一个男人
总体来说，面向对象思想就是把事件万物分类
什么是面向对象
面向对象编程(Object-Oriented Programming OOP)
面向对象编程的本质就是：以类的方式组织代码，以对象的形式封装数据。
面向对象的过程就是找对象、建立对象、使用对象、维护对象的关系的过程。
类和对象：
类：对现实世界中某类事物的描述,是抽象的，概念上的定义。
就是赋予一个事物一定的属性，是抽象的
例如：人可以是一个类但是你不知道他的名字和他的基本信息，他就是个抽象的东西
对象：事物具体存在的个体。
给某个事物的属性赋值，
例如给人这个类的属性赋值那么这个人就是一个实体的可操作的
抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用
例如：生物，这个类只能看出这是个“活”的但是并不知道这是个什么东西
人这个类继承了生物这个抽象类；那么你就知道人是个生物，若是想知道他是谁有什么特点
就必须把继承了生物的这个人进行实例化：就是给人这个类拥有的属性赋值
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
接口
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类相似点：
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口特性
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
成员变量和局部变量的区别
作用域
成员变量：针对整个类有效。
局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)
存储位置
成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。
当方法调用完，或者语句结束后，就自动释放。
初始值
成员变量：有默认初始值。
局部变量：没有默认初始值，使用前必须赋值。
构造方法：
特点：
方法名与类名相同
没有返回类型
没有返回值
作用：构造函数是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造函数，
构造方法的注意事项:
如果一个自定义类没有构造方法，系统会默认给出一个无参构造方法。
如果一个自定义类提供了构造方法，那么，系统将不再给出无参构造方法。
这个时候，你可以不使用无参构造方法。
如果你想使用，那么，就必须手动给出无参构造方法。
一般情况下，我们的自定义类都要手动给出无参构造方法。
面向对象三大特性：
封装
隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
继承
提高代码复用性；继承是多态的前提。
大概意思就像张三他爸留了好多的遗产张三可以不用努力就可以轻易获得财富，但是也可以通过自己努力去创造财富同样也可以去改变他爸留下的遗产，例如：他去嫖娼被抓花了一大笔钱，那么张三的余额就会少一大笔钱，
同样张三的哥哥张四也能利用这个遗产。
多态
父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是现有类后又对象。类是对象的模板。
类与对象的关系
类是一种抽象的数据类型，它是对某一类事务整体描述/定义，但是并不能代表某一个具体的事物。
动物、植物、手机、电脑……等抽象的事物。
Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
对象是抽象概念的具体实例
比如张三就是人的一个具体的实例。
能够体现出特点，展现出功能的是具体的实例，而不是抽象的概念。
封装
通俗理解就是：该漏的漏，该藏的藏。
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问，这成为信息隐藏。
一句话：属性私有，get/set
优点：
良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员变量进行更精确的控制。
隐藏信息，实现细节。
例如：某位女士想借张三的手机使用，张三可能会把某系浏览器的记录删除而不让那位女士看到，也不会让那位女士去动自己的vx钱包
创建对象和使用对象
废话不说上代码
public class Books {
//对象
//属性
//封装
private int bookId;
private String bookName;
private String bookAuthor;
private int bookNum;
private double bookPrice;
private String introduce;
// 上面的属性设置为私有的，只有本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
//构建方法
//无参的构造方法
public Books() {
}
//有参的构造方法
public Books(int bookId, String bookName, String bookAuthor, int bookNum, double bookPrice, String introduce) {
this.bookId = bookId;
this.bookName = bookName;
this.bookAuthor = bookAuthor;
this.bookNum = bookNum;
this.bookPrice = bookPrice;
this.introduce = introduce;
}
//getter方法 get 获得这个数据
//setter方法 set 给这个数据设置值 可以在 set 做一些验证判断
public int getBookId() {
return bookId;
}
public void setBookId(int bookId) {
this.bookId = bookId;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getBookAuthor() {
return bookAuthor;
}
public void setBookAuthor(String bookAuthor) {
this.bookAuthor = bookAuthor;
}
public int getBookNum() {
return bookNum;
}
public void setBookNum(int bookNum) {
if (bookNum<=100&&bookNum>=0){
this.bookNum = bookNum;
}
}
public double getBookPrice() {
return bookPrice;
}
public void setBookPrice(double bookPrice) {
this.bookPrice = bookPrice;
}
public String getIntroduce() {
return introduce;
}
public void setIntroduce(String introduce) {
this.introduce = introduce;
}
//toString方法方便打印输出
@Override
public String toString() {
return "Books{" +
"bookId=" + bookId +
", bookName='" + bookName + '\'' +
", bookAuthor='" + bookAuthor + '\'' +
", bookNum=" + bookNum +
", bookPrice=" + bookPrice +
", introduce='" + introduce + '\'' +
'}';
}
}
对象的实例化
public class test {
public static void main(String[] args) {
Books books = new Books();
//给对象赋值 对象实例化的过程
books.setBookId(3);
books.setBookName("桃花结");
books.setBookAuthor("甘蔗");
books.setBookNum(1);
books.setBookPrice(4.5);
books.setIntroduce("新人新井新钻头，越钻越深越出油。");
//使用toString方法
System.out.println(books.toString());
}
}
继承
继承的本质是对某一批类的抽象。用extends关键字，子类(派生类)是父类(基类)的扩展。
Object类：Java中，无论写不写entents Object类，所有的类都默认直接或间接继承Object类。
super：可以和this关键字对比。this是本身调用者这个对象(无继承关系时也可以使用)，super是指向父类对象的引用(只能在有继承关系时使用)。
方法重写(和重载不同意义)：重写都是针对的方法，属性没有重写的说法。
子类继承父类，会拥有父类的全部public属性和全部public方法。
子类继承父类，不会拥有父类的private属性和private方法。
Java的继承是单继承：一个儿子，只能有一个父亲；一个父类，可以用多个子类。
public class Person {
public int age = 5;
public int getAge(){
return this.age;
}
}
public class Student extends Person {
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
System.out.println( student.getAge());
}
}
