面向对象的介绍：

面向对象有四个概念：封装、继承、多态和抽象。

面向过程：

面向过程的思想是把一个项目、一件事情按照一定的顺序，从头到尾一步一步地做下去，先做什么，后做什么，一直到结束。这种思想比较好理解，其实这也是一个人做事的方法。

面向对象：

面向对象的思想史把一个项目、一个事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责某方面的功能，最后再有这些部分组合成一个整体。这种思想比较适合多人的分工工作，就像一个大的机关，分成各个部门，每个部门分别负责某个项目，各个部门可以充分发挥自己的特色，之哟啊符合一定前提就行了你。

面向对象就是模拟日常行为中的规律，运用Java的规范进行设计和开发

Object类：

Object类是Java所有类的父类，任何类在默认下都是Object的子类

Object在java.lang包中。这个包不惜要导入就可以直接使用

Object常用方法：

toString()

所有的类都继承自Object(对象)，因此：所有的类中都有toString()方法

为了方便查看，一般都会复写

//  方法的复写 
public String toString(){
        return  "{" + this.width+ this.height+this.weight+this.color+"}";
    }

== equals

基本数据类型（byte, short ,int, long float double)使用 == 比较

引用数据类型（数组String) 自定义的类，需要使用equals方法比较

代码的执行顺序：

public class Demo04 {
    // 普通类属性
    int size = 0;
    //代码块
    {
        size = 10;
    }
    //  静态变量
    static  int count = 30;
    //静态代码块
    static{
        count = 10;
    }
    
    //构造方法
    public  Demo04(){
        System.out.println("构造方法");
        System.out.println(count);   //10
        System.out.println(size);  //10
    }



}

构造方法和方法重载

构造方法：

先构造类的对象，再给属性赋值，通过多条语句实现 例如：

Army army = new Army();
army.name = "sam";
asrmy.age = 25;

new关键字后面跟随的就是类的构造方法，这个方法名和类名相同，没有返回值修饰符，默认是public关键字修饰

构造方法的意义：

JVM分配内存，创建需要使用的对象。

拥有内存的对象才可以操作数据

例子：

package edu.xcdq;

public class Main {


    public String name = "无名";
    public String sex = "man";

    public void print() {
        System.out.println("person的自白:\n我的昵称叫" + this.name + ",性别是:" + this.sex + "。");
    }
}

/**
 * 构造类的对象，并给属性赋值
 */

class TestSample {
    public static void main(String[] args) {
        Main main = new Main();
        main.name = "张三";
        main.sex = "男";
        System.out.println("姓名：" + main.name + "性别" + main.sex);
    }

}

打印结果:

姓名 ：张三 性别： 男

可否在创建对象的时候就完成赋值操作呢❓：

package edu.xcdq;

/**
 * @version 1.0
 * @author: jiazhihao
 * @date: 2021-05-06 09:08
 */

/**
 * 创建对象的时候就进行赋值操作
 */
public class Person {
    public String name = "无名";
    public String sex = "man";

    public Person() {
        this.name = "山姆";
        this.sex = "男";
    }

    public boolean print() {
        System.out.println("person的自白:\n我的昵称叫" + this.name + ",性别是:" + this.sex + "。");
        return true;
    }
}

/**
 * // * 创建类的对象 并给属性赋值
 * // *
 */

class TestSample1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.sex = "男";
        System.out.println(person.print());
    }
}

构造方法的名称和类名相同，没有返回值类型。构造方法的主要作用就是在创建对象时执行一些初始化操作：如给成员属性赋初始值

方法重载：

虽然通过构造方法完成了对象成员属性的赋值，但时属性值已经在构造方法中固定了，能不能在构造对象的时候完成不同实行的动态赋值呢❓：

package edu.xcdq;

/**
 * @version 1.0
 * @author: jiazhihao
 * @date: 2021-05-06 09:40
 */
public class chongzai {

        public String name = "无名";
        public String sex = "man";

        public chongzai(){
            this.name = "山姆";
            this.sex = "男";
        }
        public chongzai(String name) {
            this.name = name;
        }
        public chongzai(String name,String sex){
            super();
            this.name = name;
            this.sex = sex;
        }

        public void print() {
            System.out.print("person的自白:\n我的昵称叫" + this.name + ",性别是:" + this.sex + "。\n");


        }
    }

    /**
     * */
    class T{
        public static void main(String[] args) {
            chongzai c = new chongzai();
            c.print();
            chongzai l  = new chongzai("李四");
            l.print();
            chongzai a = new chongzai("小李","女");
            a.print();
        }
    }

上面代码中有三个构造方法，方法名相同，参数列表不同，这成为构造方法的重载，可以通过构造方法的重载来实现多种初始化行为，在创建对象时可以根据需要选择合适的构造方法

方法重载的判断依据如下。

1：必须在同一个类中

2：方法名相同

3参数列表（方法参数的个数或参数类型）不同。

4：与方法返回值和方法修饰符没有任何关系。

5：在使用this 调用自身的其他构造方法时，只能作为第一条语句。

Static

之前创建对象是先分配内存，然后可以使用对象在分配的内存中操作数据。static则打破了这个规则，只用该关键字修饰的属性、方法和代码块可以在没有创建对象的前提下就拥有内存，从而操作数据。通过static修饰的元素因为不是通过对象创建，所以在内存中只有一份

static 修饰的变量属于这个类所有，即由这个类创建的所有对象共用同一个static变量。通常把 static修饰的属性和方法成为类属性（类变量）、类方法。不适用static修饰的属性和方法属于单个变量，通常称为实例属性（实例变量）、实例方法。使用static修饰方法的最常见的例子是我们熟悉的main()方法

案例代码：

package edu.xcdq;

import com.sun.source.tree.NewArrayTree;
import jdk.swing.interop.SwingInterOpUtils;

/**
 * @version 1.0
 * @author: jiazhihao
 * @date: 2021-05-06 10:01
 */
public class StaticTestSample {
    static int j;
    static int s = 80;
    int i;
    int k = 55;

    static {
        j = 5;
        System.out.println("j的初始化值为：" + j);
    }

    public StaticTestSample() {
        i = 20;
        System.out.println("i的初始化值为：" + i);
    }

    public void getNum() {
        System.out.println("得到j的值为：" + j);
    }

    public static void main(String[] args) {
        StaticTestSample st = new StaticTestSample();
        System.out.println("j的值为：" + StaticTestSample.j);
        st.getNum();

        System.out.println("s的值为：" + StaticTestSample.s);
        System.out.println("k的值为：" + st.k);
    }
}

从结果中得到以下结论：

1：在加载类的过程中，完成静态变量的北村分配，在执行静态代码块，两者是在创建对象之前执行的

2：类属性、类方法可以通过类名和对象名访问，实例属性、实例方法只能通过对象名访问。

3：类名字只能访问类属性和其他类方法

内部类：

在一个类的累不写的类就被称为内部类。

内部类可以是public，也可以是private，使用内部类的原因通常是以下几种。、

1：内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据。

2：内部类可以对同一个包中的其他类隐藏起来。

3：当想要定义一个回调函数且不想编写大量代码时，使用匿名（anonymous）内部类比较便捷。

4：某种意义上的多继承

案例代码：

package edu.xcdq;

/**
 * @version 1.0
 * @author: jiazhihao
 * @date: 2021-05-06 10:17
 */
public class InnerClassTest {
    public int outFiled1 = 1;
    protected int outFiled2 = 2;
    int outFiled3 = 3;
    private int outFiled4 = 4;

    public InnerClassTest() {
        //在外部类对象内部，通过 new InnerClass ,直接创建内部类对象
        InnerClass innerOBJ = new InnerClass();
        System.out.println("创建" + this.getClass().getCanonicalName() + "对象");
        System.out.println("其内部类outFiled1字段的值为：" + innerOBJ.outFiled5);
        System.out.println("其内部类outFiled2字段的值为：" + innerOBJ.outFiled6);
        System.out.println("其内部类outFiled3字段的值为：" + innerOBJ.outFiled7);
        System.out.println("其内部类outFiled4字段的值为：" + innerOBJ.outFiled8);
        System.out.println(this.getClass().getCanonicalName() +"\n\n\n\sffewfadfrgadfgrefdsa");
        // this.getClass().getCanonicalName() 返回值为edu.xcdq.InnerClassTest
    }

    /**
     * getClass()是java中Object类的一个方法，其原型为：
     *
     * public final Class> getClass()
     *
     * 返回值为 当前运行时类的Class对象。
     * */

    public class InnerClass {
        public int outFiled5 = 5;
        protected int outFiled6 = 6;
        int outFiled7 = 7;
        private int outFiled8 = 8;

        public InnerClass() {
            System.out.println("创建" + this.getClass().getSimpleName() + "对象");
            System.out.println("其外部类outFiled1字段的值为：" + outFiled1);
            System.out.println("其外部类outFiled2字段的值为：" + outFiled2);
            System.out.println("其外部类outFiled3字段的值为：" + outFiled3);
            System.out.println("其外部类outFiled4字段的值为：" + outFiled4);
        }
    }

    public static void main(String[] args) {
        InnerClassTest outerOBJ = new InnerClassTest();
        //不在外部类内部使用方法：先外部类对象，由外部类对象.new 内部类构建方法的方式初级内部类对象
        InnerClass innerOBJ = outerOBJ.new InnerClass();
    }

}

单个类的顺序：

案例代码：

package edu.xcdq;

/**
 * @version 1.0
 * @author: jiazhihao
 * @date: 2021-05-06 11:05
 */
public class InitialOrderTest {
    //静态变量
    public static String staticField = "静态变量";
    //变量
    public String field = "变量";
    // 静态初始化
    static {
        System.out.println("静态代码块初始化");
        System.out.println("静态变量" + staticField);
    }
    //代码块初始化
    {
        System.out.println("普通代码块初始化");
        System.out.println("普通变量"+field);
    }
    //构造方法
    public InitialOrderTest(){
        System.out.println("构造方法");
    }
    public static  void main(String [] args){
        new InitialOrderTest();
    }
}

可以看到

，对于静态变量、静态初始化块、变量、初始化块、构造方法，他们的初始化顺序依次是（静态变量、静态初始化块）、（变量、初始化块）、构造方法

执行顺序

1、静态 static修饰的内容在整个类中最先执行

1、1如果都是static修饰的变量和代码块    谁写在代码的前面先执行谁

2、代码块和普通类属性其次执行，

2、1普通类属性和代码块谁写在前面先执行那个谁

3、构造方法的执行

final：最终的

被final修饰的成员值在程序中不能发生改变