类和对象_初步(JAVA)

1.面向对象的初步认识

 1.1什么是面向对象

面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人 们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

1.2面向对象与面向过程

1.传统洗衣服的过程

2.现代洗衣服的过程

总共有四个对象：人、洗衣机、洗衣粉、衣服。

整个洗衣服的过程相较于传统洗衣服的过程，就可以简化为：人将衣服放进洗衣机-->倒入洗衣粉-->启动洗衣机-->洗衣机就会完成洗衣过程并且甩干
整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关新洗衣机具体是如何洗衣服的，是如何甩干的

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。

2.类的定义和使用

 2.1简单认识类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

2.2类的定义格式（JAVA）

// 创建类
public class ClassName{  
    private int person;       // 字段(属性) 或者 成员变量
    public method(){         //行为或者成员方法
        ....
     }   
}

一个.class文件只能有一个public 修饰的类

类中的成员变量如果没有任何访问修饰限定符，自动是default

访问权限修饰符

范围	private	default(包访问权限)	protect(不同包的非子类才不能访问)	public
同一个包中，同一个类	yes	yes	yes	yes
同一个包的，不同类		yes	yes	yes
不同包中的子类			yes	yes
不同包中的非子类				yes

下面用狗这个对象作为例子

class PetDog {

//成员变量（狗的静态属性）
    public String name;//名字
    public String color;//颜色


//成员方法（狗的行为）
    public void barks() {
         System.out.println(name + ": 旺旺旺~~~");
     }

//成员方法（狗的行为）
public void wag() {
     System.out.println(name + ": 摇尾巴~~~");
    }
 }

3.类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自 带的内置类型，而类是用户自定义了一个新的类型，比如上面举例的的PetDog类。它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)----》把抽象的狗“具体实现”

还是以PetDog类为例

public class Main{
    public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
 }
//实例化后我们就能描述一个实际个体的狗，他有名字，叫阿黄，颜色是黑黄的。

注意事项：

1.new 关键字用于创建一个对象的实例。

2.使用 . 来访问对象中的属性和方法。

3.同一个类可以创建多个实例。

3.2类和对象的说明

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

4. this引用

4.1什么是this引用？

首先先了解一个知识点：成员变量如果不初始化，编译器会默认初始化为相应的默认值，如图：

好了，下面我们来看看这段代码的输出值。

/**
 * Created with IntelliJ IDEA
 * Description:
 * User:34398
 * Date:2024-03-16
 * Time:22:12
 */
public class Data {

    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        year = year;
        month = month;
        day = day;
    }

    public void printDate(){

        System.out.println(year);
    }

    public static void main(String[] args) {
        Data data=new Data();
        data.setDay(10,5,1);
        data.printDate();
    }
}

输出值是0，问题就在这里，方法内的引用名和类变量名相同，导致无法初始化类变量

这是this派上了用场

在看下面代码

/**
 * Created with IntelliJ IDEA
 * Description:
 * User:34398
 * Date:2024-03-16
 * Time:22:12
 */
public class Data {

    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate(){

        System.out.println(year);
    }

    public static void main(String[] args) {
        Data data=new Data();
        data.setDay(10,5,1);
        data.printDate();
    }
}

此时输出的就是10了。

4.2this引用的特性

 1.this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

 2. this只能在"成员方法"中使用

 3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法 对象的引用传递给该成员方法，this负责来接收

在实际过程中，编译器会把，成员方法中，隐藏的this参数还原（类型就是所定义的类），此时成员方法中就可以用this访问当前类中的所有成员变量（除了类变量）

5.对象的构造及初始化

5.1如何初始化对象

上面setData的代码就是一种初始化方式，但是这样比较麻烦，所以构造方法就派上了用场。

5.2构造方法

5.2.1概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次，其次没有返回值，连void都不用写。

注意：构造方法只是用于初始化成员变量，不负责给对象开辟空间

5.2.2特性

1.名字与类名相同

2.没有返回值

3.可以重载（按照参数类型，数量）

4.只有在创建对象是调用一次

5.若用户没有定义构造方法，编译器自动生成一个不带参数的构造方法

6.一旦用户定义了构造方法，编译器不再生成构造方法

7.在一个构造方法中，也可以用this()来调用其他的构造方法，括号内，按照具体构造方法的参数进行使用（注意，若使用this(),那么他必须在构造方法的第一条语句）

 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        // 如果编译器会生成，则生成的构造方法一定是无参的
        // 则此处创建对象是可以通过编译的
        // 但实际情况是：编译期报错
        Date d = new Date();
        d.printDate();
    }
 }
 
/*
 Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
  需要: int,int,int
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同
*/
 public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
        //System.out.println(year);   注释取消掉，编译会失败
        this(1900, 1, 1);
        
        //this.year = 1900;
        //this.month = 1;
        //this.day = 1;
    }
 
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
 }

8.不能形成环，既两个构造方法循环调用

5.3初始化方式

5.3.1默认初始化

只有成员变量（类中，成员方法外部）才能自动默认初始化，如果是局部变量（成员方法）则必须手动初始化，否则编译器报错。

初始化表见上文 4.1

5.3.2就地初始化

在声明成员变量时，就直接给出了初始值。

注意：：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

6.封装

6.1封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说 就是套壳屏蔽细节。

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用 户来和计算机进行交互，完成日常事务。

但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

我们不需要了解内部的运行细节，只需要知道如何操作这些仪器就可以完成相应的功能。

6.2 访问限定符

Java中主要通过类和访问权限来实现封装：

1.类：可以将数据以及封装数据的方法结合在一起。

2.访问权限:用来控制方法或者字段能否直接在类外使用。（见2.2图）

6.3封装扩展之包

6.3.1包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式

6.3.2 导入包中的类

方法一：import java.util.具体类名;

 import java.util.Date;//Data是一个类的类名,util是JAVA中的一个包
 public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
 }

2.方法二：import java.util.*

 import java.util.*;//这样不仅能访问util包中的Data类，还可以任意访问包的其他类
 public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
 }

虽然方法二看起来要比方法一简单，但我们建议使用第一种，虽然它相对麻烦一点。

原因如下：

import java.util.*;
 import java.sql.*;
 public class Test {
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
    }
 }
 
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
  java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配
这个时候编译器就不知道你是要用那个包的Data类了

扩展：可以使用import static导入包中静态的方法和字段。

public class MathUtils {
    public static final double PI = 3.14159;
    
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static double square(double x) {
        return x * x;
    }
}

import static packageName.MathUtils.*;

public class Example {
    public static void main(String[] args) {
        int sum = add(3, 5); // 直接调用MathUtils类中的静态方法add()
        double area = PI * square(2.0); // 直接使用MathUtils类中的静态字段PI和静态方法square()
    }
}

这样一来，就可以直接使用packageName包中，MathUtils类里的静态变量PI和静态方法add()、square()。

注意：最后的         .*   是固定写法

6.3.3自定义包

基本原则：

1.在文件的最上方加上一个 package 语句指定该代码在哪个包中.

2.包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.baidu.demo1).

3.包名要和代码路径相匹配.比如创建com.baidu.demo1 的包, 那么会存在一个对应的路径com/baidu/demo1 来存储代码.

4.如果一个类没有 package 语句, 则该类被放到一个默认包（src）中.

步骤：

此时生成了一个自定义包（com.baidu.demo3）

在包中创建一个类即可

在磁盘中我们看到，idea已经创建了这个结构

7.static成员

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom;
 
    //实例代码块
    {
        this.name = "hyy";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
     }
 // 静态代码块
    static {
         classRoom = "306";
         System.out.println("I am static init()!");
     }

     public Student(){
         System.out.println("I am Student init()!");
     }

     public static void main(String[] args) {
             Student s1 = new Student();
             Student s2 = new Student();
         }
 }

7.1类成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的。（static不能修饰局部变量）

7.2  static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

静态成员变量特性：

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

5.不能使用this.来访问静态成员变量。

7.3static修饰成员方法

被static修饰的成员方法称为静态成员方法（静态方法），是类的方法，不是某个对象所特有的。所以也叫类方法。

静态成员一般是通过 静态方法来访问的。

public class Student{
    // ...
    
    private static String classRoom = "306";
    
    // ...
    
    public static String getClassRoom(){
        return classRoom;
    }
 }
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
 }

输出结果是：306

静态方法特性：

1.不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

5.静态方法不能被重写，不能用来实现多态

6.静态方法可以重载

7.4静态成员变量初始化

1.就地初始化

                在定义时就赋值初始值

2.静态代码块初始化

              什么是代码块？看下面

8.代码块

8.1概念：

用{}定义的一段代码，成为代码块。根据代码块的定义位置和关键字可分为：

普通代码块

构造块

静态块

同步代码块（后续讲解多线程部分再谈）

8.2普通代码块

定义在方法中的代码块.

public class Main{
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10 ;
            System.out.println("x1 = " +x);
        }
        int x = 100 ;
        System.out.println("x2 = " +x);
    }
 }
 
// 执行结果
x1 = 10
 x2 = 100

8.3 构造代码块

也叫实例代码块。构造代码块一般用于初始化实例成员变量。

public class Student{
    //实例成员变量
    private String name;
    private String gender;
    private  int age;
    private double score;
    
    public Student() {
        System.out.println("I am Student init()!");
    }
    
    //实例代码块
    {
        this.name = "hyy";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
 }
 
public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
 }
 
// 运行结果
I am instance init()!
 I am Student init()!
 name: hyy age: 12 sex: man

8.4静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

注意事项：

1.静态代码块不管生成多少个对象，其只会执行一次

2.静态成员变量是类的属性（不依赖于对象），因此是在JVM加载类时开辟空间并初始化的

3。如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

4.实例代码块只有在创建对象时才会执行

5.记住一个原则，静态的用类名访问，非静态的用对象的引用访问

8.5代码块的执行顺序

1. 静态代码块
2. 实例代码块
3. 对应构造方法
4. 同种类型，按照定义顺序来

注意：如果存在父类，那么先执行父类的静态块，然后是子类的静态块，之后在执行父类的示例代码块，构造方法，最后到子类按顺序执行。