Java的 “万物皆对象“

面向过程和面向对象的区别

面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体步骤和过程，注重的是过程中的具体行为，以函数为最小单位，考虑怎么做。

面向对象：注重找“参与者”，将功能封装进对象中，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

案例：小明从冰箱里拿东西

面向过程：

面向对象:

面向过程 —> 面向对象 , 其实就是由执行者 —> 指挥者的 一个过渡

类和对象的关系

万物皆对象

对象：具体的事物，具体的实体，具体的实例，模板下具体的产品

类：对对象向上抽取出像的部分，公布部分，形成类，类是抽象的，是一个模板，一般在写代码的时候先写类，然后再根据类创建对应的对象

类是对象的抽象，对象是类的实例化

类和对象的创建

类的创建

1.属性（field 成员变量）

属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。

属性定义格式：

[修饰符] 属性类型 属性名 = [默认值]；

2.方法

方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法定义格式：

[修饰符] 方法返回类型 方法名（形参列表）{

​ //Java语句

}

我们以上面王者荣耀英雄类创建为例：

//创建英雄类
public class Hero {
    
    
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    //技能
    public void Kill(int number){
    
    
        //根据输入的数字释放几技能
        System.out.println(Name+"释放"+number+"技能！！！");
    }
    //输出该英雄的属性
    public void print(){
    
    
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }

}

对象的创建

接下来我们对我们创建好的类来创建对象

public class TestCode01 {
    
    
    //main方法，程序的入口
    public static void main(String[] args) {
    
    
        //创建一个对象(英雄)-->马克波罗
        Hero make = new Hero();
        make.Name = "马克波罗";
        make.Survive = 4;
        make.Attack = 6;
        make.Skill = 6;
        make.Difficulty = 5;
        //再创建一个英雄-->澜
        Hero lan = new Hero();
        lan.Name = "澜";
        lan.Survive = 3;
        lan.Attack = 5;
        lan.Skill = 4;
        lan.Difficulty = 6;
        lan.Kill(1);
        //输出两个英雄的属性
        make.print();
        System.out.println("-------------");
        lan.print();
        //释放技能
        make.Kill(3);
        System.out.println("-------------");
        lan.Kill(2);
    }
}

结果: 每个英雄都有相同的属性，每个属性又有不同的值，通过类我们可以创建很多个对象，每个对象又有不同的属性值。
比如：王者里的一百多个英雄，每个都有不同的特点。

创建对象的过程：
（1）在第一次遇到一个类的时候，对这个类要进行加载，只加载一次。
（2）创建对象，在堆中开辟空间
（3）对对象进行初始化操作，属性赋值都是默认的初始值。
（4）new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值

构造器

对象都是new出来的，new关键字实际上在调用一个方法，这个方法叫做构造方法（构造器）

调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器（空构造器）

构造方法格式：

[修饰符] 构造器名字（）{

}

构造器和方法的区别：

• 没有方法的返回值
• 方法体内部不能有return语句
• 构造器的名字很特殊，必须跟类名一致

构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。

调用构造器的目的是给属性进行赋值操作的。

注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。

下面例子：

class Hero{
    
    
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    public Hero(){
    
    
        Survive=4;
        Attack=5;
        Skill=6;
        Difficulty=7;
    }
    public void print(){
    
    
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }
}
public class TestCode01 {
    
    
    public static void main(String[] args) {
    
    
        //创建两个英雄对象
        Hero make = new Hero();
        make.Name="马克";
        Hero lan=new Hero();
        lan.Name="澜";
        //输出两个属性
        make.print();
        lan.print();
    }
}

因为我们在构造器里面赋值了，所以我们创建对象的时候属性就一样了

实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写，我们要用构造器赋值就要对构造器重载

构造器重载

一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作

一般我们会重载构造器，在重载的构造器中进行属性赋值操作

在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。所以我们重载构造器时，一般要保留默认构造器

当形参名字和属性名字重名的时候，会出现就近原则：在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象

this的使用

this就是指当前的对象

this可以修饰属性

当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰（如果不发生重名问题的话，实际上你要是访问属性也可以省略this.）

this修饰方法

在同一个类中，方法可以互相调用，this.可以省略不写。

this可以修饰构造器

同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

static修饰

static可以修饰：属性、方法、代码块、内部类

static修饰属性

在类加载的时候，会将静态内容也加载到方法区的静态域中，静态的内容先于对象存在，并且这个静态内容被所有该类的对象共享。

• 在类加载的时候一起加载入方法区中的静态域中
• 先于对象存在
• 访问方式： 对象名.属性名 类名.属性名（推荐）

static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 -->这个情况下，就可以用static修饰的属性。

static修饰方法：

• static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
• 在静态方法中不能使用this关键字
• 在静态方法中不能访问非静态的方法
• 在静态方法中不能访问非静态的属性
• 静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐）
• 在同一个类中可以直接调用静态方法

代码块

代码块的分类： 普通块、构造块、静态块、同步块（多线程）

代码块执行顺序： 最先执行静态块–>再执行构造块，（不常用）–>再执行构造器–>再执行方法中的普通块

public class Test {
    
    
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
    
    
        System.out.println("-----a");
        {
    
    
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }

    }
    public static void b(){
    
    
        System.out.println("------b");
    }
    //构造块
    {
    
    
        System.out.println("------这是构造块");
    }
    //静态块
    static{
    
    
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test(){
    
    
        System.out.println("这是空构造器");
    }
    public Test(int a){
    
    
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
    
    
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

包（import）

包的作用： 为了解决重名的作用，解决权限问题

包名的定义：

• 名字全部小写

• 中间用.隔开

• 一般都是公司域名倒着写：com.jd 、com.taobao

• 加上模块名字 ：com.taobao.login

• 不能使用系统中的关键字：null

• 包声明的位置一般都在非注释代码的第一行

导包：

（1）使用不同包下的类要需要导包， 例如：import java.util.Date;
（2）在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
（3）同一个包下的类想使用不需要导包，可以直接使用。
（4）在java.lang包下的类，可以直接使用无需导包
（5）可以直接导入*：

静态导入：

//静态导入：
import static java.lang.Math.*;
//导入：java.lang下的Math类中的所有静态的内容

public class Test {
    
    
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
    
    
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
    public static int round(double a){
    
    
        return 1000;
    }
}