面向对象思想
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索面向对象适合处理复杂的问题，适合处理需要多人协作的问题
面向过程
步骤清晰简单，第一步做什么，第二步做什么面对过程适合处理一些较为简单的问题
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。具体到围观操作，仍需要面向过程的思路去分析
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
封装继承多态
从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板
方法*
方法的定义
//Demo01就是一个类
public class Demo01 {
//main方法
public static void main(String[] args) {
}
//return 结束方法，返回一个结果
public String sayHello(){
return "Hello World!";
}
}
方法调用
静态与动态方法
由于static修饰（静态）的表示属于类，因此如果想访问类的方法或者遍历，则可以直接通过类名.方法名() / 类名.变量名 进行访问所谓的动态和静态的区别：对于一个类来说，如果没有被static所修饰的变量或者成员方法，那么每实例一个新的对象（new），这些非static修饰的都属于对象
public class Demo02 {
public static void main(String[] args) {
//静态方法 static
say();
//非静态方法
Student stu = new Student();
stu.hello();
}
}
形参和实参
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。
值传递和引用传递
这里借一下大佬的笔记，就不一一去记录了。链接地址
类与对象类是一种抽象的数据类型，它是对某一类事物整体藐视/定义，但是并不能代表某一个具体的事物。
Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该拒北的特点和行为 对象是抽象概念的具体实例
张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。 创建与初始化对象
使用new关键字创建对象使用new关键字创建的适合，除了分配内存空间之外，还会给创建号的对象，进行默认的初始化以及对类中构造器的调用
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象，student对象就是一个Student类的具体实例
Student XiaoMing = new Student();
Student XiaoHong = new Student();
XiaoMing.name = "小明";
XiaoMing.age=21;
XiaoHong.name = "小红";
XiaoHong.age=21;
System.out.print("我叫"+XiaoMing.name+"今年"+XiaoMing.age);
XiaoMing.study();
System.out.println("我叫"+XiaoHong.name+"今年"+XiaoHong.age);
}
}
class Student {
//数学：字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
类中的构造器也称为构造方法，是在进行创建对象的适合必须要调用的。并且构造器有两个特点：
必须和类的名字相同
必须没有返回类型，也不能写void
在你创建了一个类时，他默认会有一个无参的空的构造器，在你创建有参的构造器后，他就会失去，所以无参就必须显示定义，一般我们可以在创建构造器的时候，将无参的构造器先创建可以为空。
使用new关键字本质上是在调用构造器
public class Person {
String name;
int age;
public Person(){
}
public Person(String name){
this.name = name;
}
public Person(String name,int age){
this.name = name;
this.age=age;
}
}
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
Person per1=new Person();
Person per2=new Person("煎饼");
Person per3=new Person("煎饼",21);
System.out.println("无参是："+per1.name+" "+per1.age);
System.out.println("有参是："+per2.name+" "+per2.age);
System.out.println("多参是："+per3.name+" "+per3.age);
}
}
通过以上代码，可以总结出，在new一个对象的时候，根据你的参数个数，会选择对应的构造器，完成对应的构造器内容的初始化。
注意点：定义有参构造后，如果想要使用无参构造，需要显示的定义一个无参的构造
堆&栈 （后期理解清楚再详细写一篇） 封装
该露的露，该藏的藏
程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而是通过操作接口来访问，这称为信息隐藏。private：私有。带private修饰符的属性或者方法外部是无法直接进行调用的。alt+insert，快捷创建get/set方法
//类 private：私有
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;//年龄
//因为属性是私有的，外部无法直接进行调用，需要通过方法来进行对私有属性的修改
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 int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
public class Application {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("煎饼");
stu1.setId(1);
stu1.setSex('男');
stu1.setAge(18);
System.out.println("我是"+stu1.getName()+stu1.getId()+"号，性别"+stu1.getSex()+"，现在"+stu1.getAge());
}
}
我们可以再set方法里面去做限制，例如年龄肯定是没有小于0或是几百岁的，又或者性别一般来说只有男和女。在set接收数据的时候做一个判断。
public void setAge(int age) {
if(age<0 || age>120){//做一个判断，它是否是一个正常的年龄
this.age=0;
}else{
this.age = age;
}
}
封装就如同我们电脑一般，他就是封装好的，只留下了一些接口（I/o设备）以提供我们操作，而不是让我们去直接对电路进行修改。
继承①继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模extends的意思是“扩展”。子类是父类的扩展JAVA中类只有单继承，没有多继承！继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。继承关系的两个类，一个为子类（派生类）一个为父类（基类）。子类继承父类，使用关键字extends来表示。
父类
public class Person {
public int money01=10_000_000;//公共
private int money02 = 1000;//私有
public void say(){
System.out.println("Hello my dear son!");
}
public int getMoney02() {//私有属性，需要通过公开的方法进行操作
return money02;
}
public void setMoney02(int money02) {
this.money02 = money02;
}
}
子类，直接继承父类的内容，可以使用父类的一些方法以及属性，这里为了直观直接为空
public class Teacher extends Person{
}
主程序
public class Application {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.money01);
student.say();
System.out.println(student.getMoney02());//我使用了方法才拿到了这笔钱
}
}
在主程序中，创建对象，然后调用属性和方法时，可以看到，找不到money02，因为该属性私有，只能通过方法去访问，或者访问不了。（上节封装的知识点），通过创建get/set方法可以对私有属性进行操作。
子类继承了父类，就会拥有父类的全部方法
public公共类，可以被所有其他类所访问。相当于这是遗产，儿子能直接继承使用
protected，自身、子类及同一个包中类可以访问。
default，默认：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。
private私有类，只能被自己访问和修改。可以通过靠方法来调用，这相当于是爸爸的私房钱，需要一定的方法才能获得使用，或是无法使用
ctrl+h可以查看继承结构
可以看到Student继承Person，但是Person我们没有设置继承父类，结构上却显示继承了Object；因为所有类，默认都会继承一个Object类。 继承 ②
super与this
代表的对象不同
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件下使用
构造方法
this（）：本类的构造方法
super（）：父类的构造方法
我们还是用代码运行结果，进行理解
主程序
public class Application {
public static void main(String[] args) {
Student stu1 = new Student();//再创建对象时调用无参构造器
System.out.println("****************************");
stu1.test("小明");//调用子类test方法
System.out.println("****************************");
stu1.test1();//调用子类test1方法
}
}
父类
public class Person {
public Person(){//为了更加明显的看到运行结果，我们自行创建一个无参构造器
System.out.println("Person父类的无参调用");
}
String name = "jianbing";
public void print(){
System.out.println("Person");
}
}
子类
public class Student extends Person{
public Student(){//为了更加明显的看到运行结果，我们自行创建一个无参构造器
System.out.println("Student子类的无参调用");
}
private String name = "煎饼";
public void test(String name){
System.out.println(name);//传进来的参数
System.out.println(this.name);//子类的属性
System.out.println(super.name);//父类的属性
}
public void test1(){
print();//本类的方法
this.print();//本类的方法
super.print();//父类的方法
}
public void print(){
System.out.println("Student");
}
}
运行结果
在创建对象的时候，可以看到父类的无参构造器也进行了构造：
在子类的构造器中，隐藏了调用父类无参构造的代码，在子类构造前，除非在构造器中自行选择了父类的有参构造方法，默认都是调用父类的无参构造方法。因为父类要先完成构造，所以在子类构造前，先进行父类构造 this，表示的都是本类的属性或者方法，super使用的都是父类；在子类中与父类有同个方法名时，这边建议使用this和super，用this表示本类，这样程序结构能更加清晰。
