类与对象

类中主要包括五种结构，下面进行对这五种结构进行详细的介绍

1. 面向对象与面向过程

面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。--唯物主义（物质决定意识）

2. 类与对象的关系

类：对一类事物的描述，是抽象的、概念上的定义

对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

面向对象程序设计的重点是类的设计，设计类就是设计类的成员。

二者的关系：对象，是由类new出来的，派生出来的

3. 面向对象思想实现的规则

创建类，设计类的成员
创建类的对象
通过对象.属性 或 对象.方法调用对象的结构

补充：几个概念的使用说明

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

4. 对象的创建与对象的内存解析

[典型代码]

Person p1 = new Person();
Person p2 = new Person();
person p3 = p1;//没有创建一个型对象 只是将p1 对象的地址赋值给p3
/*
* 如果创建l一个类的多个对象 则每个对象都独立拥有类的属性(非 static0)
* 意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值
*/

6. 匿名对象:

我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。

new Person().sendemail();
new Phone().playGame();

new Phone().price = 1999;
new Phone().showPrice();//0.0\

[应用场景]

PhoneMall mall = new PhoneMall();

//匿名对象的使用
mall.show(new Phone());
其中，
class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
    
}

类的结构之一：属性'

1. 属性 vs 局部变量

1.1 相同点：

定义变量的格式：数据类型变量名 = 变量值
先声明，后使用
变量都其对应的作用域

1.2 不同点：

1.2.1 在类中声明的位置的不同

属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。

1.2.2 关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected --->封装性
目前，声明属性时，使用缺省就可以。
局部变量：不可以使用权限修饰符。

1.2.3 默认初始化值的情况：

属性：类的属性，根据其类型，都默认初始化值。
整型（byte、short、int、long：0）
浮点型（float、double：0.0）
字符型（char：0 （或'\u0000'））
布尔型（boolean：false）
引用数据类型（类、数组、接口：null）
局部变量：没默认初始化值。
- 意味着，我们在调用局部变量之前，一定要显式赋值。
- 特别地：形参在调用时，我们赋值即可。

1.2.4 在内存中加载的位置：

属性：加载到堆空间中（非static）
局部变量：加载到栈空间

2. 变量的分类：

方式一：按照数据类型：

方式二：按照在类中声明的位置：

类的结构之二：方法

定义：描述类应该具的功能 1.1 JDK中的方法：

Math类：sqrt() random() ...

Scanner类：`nextXxx()` ...

复制代码

Arrays类：`sort()`    `binarySearch()`    `toString()`     `equals()`   ...

1.2 自定义的方法：

 public void eat(){
     System.out.printly("我要吃饭！！！");
 }

 public String getNation(String nation){
     System.out.printly("当前地点为" + nation);
 }

复制代码

1.3 方法的声明：

权限修饰符 返回值类型  方法名(形参列表){

方法体

}

2. 方法的说明：

2.1 关于权限修饰符：

Java规定的4种权限修饰符：private、public、缺省、protected

详细内容请查看文章《细说面向对象三大特征》

2.2 返回值类型：

2.2.1 返回值 vs 没返回值

如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：return 数据。
如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return。如果使用的话，只能使用 return; 表示结束此方法的意思。

2.2.2 方法该不该定义返回值？

① 题目要求

② 具体问题具体分析

2.3 方法命名规范

属于标识符，遵循标识符的规则和规范，“见名知意”
方法名应遵循小驼峰命名 aaaBbbCcc
方法名最好使用英文单词，不要使用拼音或者缩写
更多规范要求请参考《Java开发手册》

2.4 关于形参列表

方法可以声明0个，1个，或多个形参。

也可以使用可变形参，但可变形参必须放到最后，详细说明请查看本章第五部分。

格式：数据类型1 形参1 数据类型2 形参2 .....

定义方法时，该不该定义形参？

① 题目要求

② 具体问题具体分析

2.5 方法体

是方法中功能的体现，通过循环分支、条件判断等语句完成复杂的逻辑关系。

方法中可以调用其他方法，同类中可以直接调用，不同类中通过类的实例化对象调用。

3. 方法的使用

同类中的方法可以直接调用当前类的属性或方法，不同类中通过类的实例化对象调用。
特殊的：方法A中又调用了自身---递归方法。（自身调用）

4. 方法的重载

4.1 重载的概念

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

"两同一不同":

相同：同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同

4.2 构成重载的实例：

// 举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
// 举例二：
// 如下的4个方法构成了重载
public void getSum(int i,int j){
    System.out.println("1");
}

public void getSum(double d1,double d2){
    System.out.println("2");
}

public void getSum(String s ,int i){
    System.out.println("3");
}

public void getSum(int i,String s){
    System.out.println("4");
}

不构成重载的实例：

public int getSum(int i,int j){
    return 0;
}
    
public void getSum(int m,int n){
        
}
    
private void getSum(int i,int j){
    
}

4.3 重载方法判断

如何判断是否构成方法重载？

严格按照定义判断：两同一不同。跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

如何确定类中某一个方法的调用：

①方法名 ---> ②参数列表

类的结构之三：构造器

构造器的作用：（只要造对象就得用构造器）

创建对象
初始化对象的信息

2. 使用说明：

如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名(形参列表){ }
一个类中定义的多个构造器，彼此构成重载
一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
一个类中，至少会有一个构造器

3. 构造器举例:

//构造器不等于方法
public Person(){
    System.out.println("Person().....");
}

public Person(String n){
    name = n;

}

public Person(String n,int a){
    name = n;
    age = a;
}

构造器默认权限和类的权限一致

总结：属性赋值的先后顺序

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

5. JavaBean的概念

所谓JavaBean，是指符合如下标准的Java类：

类是公共的
一个无参的公共的构造器
属性，且对应的get、set方法

类的结构之四：代码块

代码块(初始化块)（重要性较属性、方法、构造器差一些）

1. 代码块的作用：

用来初始化类、对象的信息

2. 分类：

代码块要是使用修饰符，只能使用static 分类：静态代码块 vs 非静态代码块

3. 静态代码块 vs 非静态代码块区别

静态代码块：

内部可以输出语句
随着类的加载而执行,而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：

内部可以输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

[举例一]

    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root(){
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root{
    static{
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid(){
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String msg){
        //通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值："
                           + msg);
    }
}
class Leaf extends Mid{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }   
    public Leaf(){
        //通过super调用父类中有一个字符串参数的构造器
        super("调用父类构造器");
        System.out.println("Leaf的构造器");
    }
}
public class LeafTest{
    public static void main(String[] args){
        new Leaf(); 
        //new Leaf();
    }
}

java类的那些事