Java基础知识（面向对象、类、构造函数）

1.面向对象与面向过程

面向对象：主要解决对象(别人)去解决问题
找别人做：省时省力(不确定具体的底层实现)
面向对象三大特点：封装 继承 多态
封装：循环 函数 类
继承：
多态：+ 重载

当面向封装了具体功能类，若要使用这个类，一般情况下，在Java中需要通过创建这个类的实体来使用。这个实体称之为对象。在开发中，我们是在不断的找封装不同功能的类。基于这些类，创建其对象，使用这些对象完成相应的操作。

面向过程：主要针对过程(步骤)去解决问题
亲力亲为 面向过程中最核心思想

面向过程，其实就是面向着具体的每一个步骤和过程，就是面对具体的每一个功能函数。这些功能函数相互调用，完成需求。

面向过程是最基本的思想,面向对象是面向过程之上的一种优化方式。面向对象是基于面向过程，对象是将功能进行了封装。只要找到了具体的类，创建出对象，就可以调用其中的具体功能。面向对象也是用来解决问题的一种思维模式。

2.对象与类

对象：真实存在的事物都叫做对象
new Scanner();
new Random();
new String();
new int[];
类：具有相似特征和行为的事物的统称
枪：M4 QBZ AK Mini 98k AWM UZI
行为：射击 扔
对象和类的关系
对象是有类所描述出来的具体的事物
如何去定义一个类
主要定义其特征和行为
特征：变量
行为：函数

new 类();
//按照类所描述的内容创建一个具体的对象出来

这里用人来举例

class person{
    //直接定义在类中的变量 成员变量
    姓名 String name;
    性别 String sex;
    年龄 int age;
    身高 double lenght;
    体重 double weight;
    肤色 String color;

    //成员函数(非static函数)
    吃   public void eat(){... return;}
    睡   public void sleep(){... return;}
}
new person();

通过代码的描述，知道类的真正意义就是在描述事物。属性和行为统称为事物中的成员。
事物的成员分为两种：成员属性和成员行为。
成员属性在代码中的体现就是成员变量
成员行为在代码中的体现就是成员函数（方法）
成员变量初始化
对象在堆中创建 其成员变量有默认初始化
默认初始化-显式初始化-针对性初始化
大家都没有 大家都一样 大家百花齐放

局部变量和成员变量的区别
区别一：定义的位置不同
成员变量定义在类中
局部变量定义在方法中或者语句里面
区别二：在内存中的位置不同
成员变量存储在堆内存的对象中
局部变量存储在栈内存的方法中
区别三：声明周期不同
成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
成员变量因为在堆内存中，所有默认的初始化值
局部变量没有默认的初始化值，必须手动的给其赋值才可以使用

3.对象的创建流程

public class PersonTest{
    public static void main(String[] args){
        Person p=new Person();
       
        System.out.println(p.name);
        System.out.println(p.age);
    
        p.speak();
        
        p.name="张三";
        
        p.age=-30;

        System.out.println(p.password);
        System.out.println(p.name);
        System.out.println(p.age);
        
        p.speak();
        System.out.println(p.getAge());
        p.setAge(10);
        p.speak();
    }
}

1.主函数先进栈
2.执行new Person()
在堆内存中开辟一个空间，分配地址(随机)
3.在对象空间中创建成员变量的空间
再对成员变量进行默认初始化
基本数据类型 整数0 小数0.0 字符0 布尔false
引用数据类型 null
成员函数并不在对象空间里
4.相应的构造函数进栈，此时先进行显示初始化
5.接着在执行构造函数中的内容 针对性初始化
6.构造函数执行完毕弹栈
7.将对象的地址传给相应的变量

4.构造方法

构造方法在使用new操作符创建对象的时候被调用。

构造方法是一种特殊的方法。有三个特殊性：
1.构造方法必须和类的名字相同。
2.构造方法没有返回值类型，连void也没有。
3.构造方法是在创建一个对象使用new操作符时调用的。

如果一个类里面没有定义任何构造函数,则会有一个隐藏的无参构造函数

权限修饰符 类名(参数列表){
    
    return;
}

class Person{
    private int age;
    private String name;
    Person(){
        this(0,null);//this(...) 调用当前类的其他构造函数 必须在第一句
        
    }
    Person(int age){
        this(age,null);
        System.out.println("1age参的");
    }
    Person(String name){
        this(0,name);
        System.out.println("1name参的");
    }
    Person(int age,String name){ //前面三个都是构造函数
   
        System.out.println("2参的");
        this.age=age;
        this.name=name;
    }
       public void show(){
        //如果局部变量没有重名 则默认用成员变量
        System.out.println(this.name+":"+this.age);
    }
    public void setAge(int age){
        //局部变量age 成员变量age
        if(age<0){
            this.age=0;
        }else{
            this.age=age;
        }
    }
    public int getAge(){
        return this.age;
    }
}

如果一个类有多个构造方法， 最好尽可能使用 this( 参数列表 ） 实现它们。 通常，无参数或参数少的构造方法可以用 this( 参数列表 ） 调用参数多的构造方法。 这样做通常可以简化代码， 使类易于阅读和维护。还应该注意，构造函数之间不能互相调用。

this关键字
this：表示当前对象的引用
成员变量的个数和对象的个数有关
成员函数的个数和对象的个数无关 始终一个
如何做区分 区分哪个对象调用的函数 this
构造函数和成员函数有什么区别？
外界调用角度
构造函数只能在创建对象时调用，对象创建完毕之后不能已创建的对象调用
成员函数只能在对象创建之后调用，可以重复的
返回值
构造函数不需要返回值
成员函数可需可不需
权限修饰符
构造函数可以用任意权限修饰符
成员函数也可以用任意权限修饰符
内部调用
构造函数能否调用成员函数？
可以
但是这个成员函数一般不会当做对象行为去看待
构造函数能否调用构造函数？
可以
this(参数列表) 调用当前类中的其他构造函数
构造函数之间不能相互调用 无限递归
而且this(…)必须在第一句！防止值的覆盖
成员函数能否调用成员函数？
可以
成员函数能否调用构造函数？
不能 但是可以new
(构造函数可以和成员函数重名！
如果一旦定义出其他的构造函数 则默认的无参构造函数不存在了！
所以建议一般把无参构造函数都写出来

private私有化关键字

成员变量 如果需要向外界访问 则public, 如不需要向外界访问 则private
但是一般而言 都会将成员变量私有化
给成员变量+private是彻底不想给外界 ,是不想随意的给外界修改
getter 成员变量访问器
setter 成员变量修改器

final 修饰变量 表示该变量所存储的地址不可改变
可以更改地址所对应的数据中的值
final必须初始化 就不能被修改 一半而言不会给成员变量+final

静态变量和成员变量有何区别
1.存储位置
静态变量在静态方法区中类所属的空间里
成员变量在堆内存中对象的所属空间里
2.生命周期
静态变量随着类(.class文件)的加载而存在，随着程序的结束而结束
成员变量随着对象的创建而存在，随着对象的消亡而消失
3.调用方式
静态变量可以对象调用 类调用
成员变量只能对象调用
4.别名
静态变量属于类的 也叫类成员
成员变量属于对象的 也叫对象特有属性

对象的创建流程

class Person{
    public static final String country="China";
    private String name;
    private int age;
    public Person(){}
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void speak(){
        System.out.println(name+":"+age+":"+country);
    }
    public static void getCountry(){
        System.out.println("Person类的国籍是"+country);
    }
}

1.javac 编译 Main.java 生成两个字节码文件
Main.class Person.class
2.java 运行 Main.class
将Main.class和Person.class文件加载进JVM
具体加载进了那里？方法区
内存：
寄存器 ：直接与CPU进行数据交互
本地方法区：主要临时存储OS（操作系统）的可执行代码
方法区：主要临池存储App的可执行代码
栈：函数栈 用于运行函数
堆：对象堆 主要存储对象数据
3.方法区中分为
静态方法区 主要存放 静态变量 静态函数
非静态方法区主要存放 构造函数 成员
4.java Main
让虚拟机在静态方法区中的Main所属空间里找主函数
5.将主函数加载进栈，开始运行
6.执行主函数中的第一句
在堆内存中开辟空间并分配地址
按照类的描述 创建成员变量并对其进行默认初始化
7.相应的构造函数进栈，从非静态方法区中的相应的类空间里 读取相应的构造函数并加载进栈
8.构造函数刚进栈 则进行显式初始化
9.开始执行构造函数中的代码，针对性初始化
为了区分哪个对象调用的这个函数 用this
10.构造函数执行完毕弹栈，将对象的地址赋予左边
11.在主函数中创建Person类型的p变量空间
空间里存的是该对象的地址
12.p对象调用speak()方法，则从非静态方法区中加载speak()的代码进栈， 同样 this做区分
成员函数中打印变量 局部-堆-静态方法区 就近原则
13.在调用静态成员时，可以直接去静态方法区中找
Person.xxx Person是因为该区域中有多个类空间 我们得指定一个
同样 调用静态函数中的打印变量 局部->静态 与堆无关 因为无对象影响
静态函数有没有this!! 没有this因为无对象 不用去堆里面找去了