（4）类与对象 ----第二部分

6.static关键字

6.1实例变量和类变量的区别

对象共享类对象

实例变量属于对象，每个对象都有自己独立的实例变量；

类变量（静态变量、static变量）属于类，所有对象共享同一个类变量。

实例变量在对象创建时分配内存，类变量在类加载时分配内存。

类变量通常用于存储与整个类相关的数据，如常量、共享配置、计数器等。它们可以在类的任何方法中访问，并且无需创建类的实例即可访问。

实例变量是在类的实例（对象）中定义的变量，每个类的实例都有一份独立的实例变量副本。它们用于存储对象的特定状态和数据，不同的对象可以有不同的实例变量值。实例变量通常在类的成员变量部分声明，而不是在方法内部。

例如：

public class Example {
    // 类变量（静态变量）
    static int classVariable = 10;

    // 实例变量
    int instanceVariable = 20;

    public static void main(String[] args) {
        // 访问类变量
        System.out.println("Class Variable: " + Example.classVariable);

        // 创建两个对象
        Example obj1 = new Example();
        Example obj2 = new Example();

        // 访问实例变量
        System.out.println("Instance Variable of obj1: " + obj1.instanceVariable);
        System.out.println("Instance Variable of obj2: " + obj2.instanceVariable);

        // 修改类变量
        Example.classVariable = 30;
        System.out.println("Class Variable after modification: " + Example.classVariable);

        // 修改obj1的实例变量
        obj1.instanceVariable = 40;
        System.out.println("Instance Variable of obj1 after modification: " + obj1.instanceVariable);
        System.out.println("Instance Variable of obj2: " + obj2.instanceVariable);
    }
}

输出结果：

Class Variable: 10
Instance Variable of obj1: 20
Instance Variable of obj2: 20
Class Variable after modification: 30
Instance Variable of obj1 after modification: 40
Instance Variable of obj2: 20

总结：

• 类变量 classVariable 是所有对象共享的，在任何一个对象修改后，所有对象访问时都会看到修改后的值。
• 实例变量 instanceVariable 是每个对象独立的，修改一个对象的实例变量不会影响其他对象的实例变量。

6.2实例方法和类方法的区别

区别：

1. 定义方式：

   • 实例方法：不使用 static 关键字修饰，属于对象。
   • 类方法：使用 static 关键字修饰，属于类。

2. 调用方式：

   • 实例方法：必须通过对象的引用来调用。
   • 类方法：可以直接通过类名调用，也可以通过对象引用调用，但推荐使用类名来调用。

3. 访问权限：

   • 实例方法：可以访问类的实例变量和类变量。
   • 类方法：只能访问类变量和其他类方法，不能直接访问实例变量和实例方法。

4. 使用场景：

   • 实例方法：通常用于需要操作实例变量或依赖于实例状态的方法。
   • 类方法：通常用于不依赖于实例状态的方法，例如工具方法或工厂方法。

例如：

public class Example {
    // 类变量
    static int classVariable = 10;

    // 实例变量
    int instanceVariable = 20;

    // 类方法
    static void classMethod() {
        System.out.println("This is a class method.");
        // 可以访问类变量
        System.out.println("Class Variable: " + classVariable);
        // 不能访问实例变量，下面的行会导致编译错误
        // System.out.println("Instance Variable: " + instanceVariable);
    }

    // 实例方法
    void instanceMethod() {
        System.out.println("This is an instance method.");
        // 可以访问实例变量
        System.out.println("Instance Variable: " + instanceVariable);
        // 可以访问类变量
        System.out.println("Class Variable: " + classVariable);
    }

    public static void main(String[] args) {
        // 调用类方法
        Example.classMethod();

        // 创建对象
        Example obj = new Example();

        // 调用实例方法
        obj.instanceMethod();
    }
}

输出结果：

This is a class method.
Class Variable: 10
This is an instance method.
Instance Variable: 20
Class Variable: 10

7.this关键字

this可以出现在实例方法和构造方法中，但不可以出现在类方法中。

7.1在构造方法中使用this

当this关键字出现在类的构造方法中，代表使用该构造方法所创建的对象。

7.2在实例方法中使用this

实例方法只能通过对象来调用，不能用类名来调用。当this关键字出现在实例方法中时，代表正在调用该方法的当前对象。

实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现，默认的格式：

this.成员变量

当static成员变量在实例方法中出现时，格式为：

类名.成员变量

例如：
 

class A{
    int x;
    static int y;
    void f(){
        this.x = 100;
        A.y = 200;
    }
}

通常情况下可以省略实例成员变量名字前面的“this.”以及static变量前面的“类名.”

但是，当实例成员变量的名字和局部变量的名字相同时，成员变量前面的“this.”不能省略。

对方法的调用相同。

8.包

包名的目的是有效区分名字相同的类，

package语句必须作为java源文件的第一条语句，定义类所在包。

一般格式：package 包名；

也可以是若干标识符加“ . ”分隔而成，例如：

package sunrise;
package sun.com.cn;

9.import语句

如果一个类想要使用的那个类和它不在一个包中，使用import语句解决。

9.1引入类库中类

为了能使用java提供的类，用import语句引入包中的类，能写多个，必须写在package语句和源文件中类的定义之间。java提供了130多个包，例如：

• java.lang:所有基本语言类（核心类库）
• java.swing:抽象窗口工具集中的图形、文本和窗口GUI类
• java.io:所有输入/输出类
• java.until:数据结构类
• java.sql:操作数据库的类
• java.net:所有实现网络功能的类
• java.applet:所有实现Java Applet的类

如果要引入一个包中所有类，可以用通配符“ * ”代替，例如：

        import java util.*;

9.2引入自定义包中的类

用户程序也可以使用import语句引入非类库中有包名类，例如：

import tom.jiafei.*;

9.3避免类名的混淆

在某些特殊情况下不能省略包名。

1.区分无包名和有包名的类

        如果一个源文件使用了一个无包名中的A类，同时又用了import语句引入了某个有包名的同名类，

如果源文件明确地引入了该类，例如：import tom.jiafei.A

如果同时使用tom.jiafei包中的A类和无名包中的A类，就不能省略包名，例如：

A a1 = new A();

tom.jiafei.A a2 = new tom.jiafei.A();

所以a1是无包名A类创建的对象，a2是tom.jiafei包中的A类创建的对象。

2.区分有包名的类

        如果一个源文件引入了两个包中同名的类，那么在使用该类时，不允许省略包名。例如：

tom.jiafei.A bird = new tom.jiafei.A();

sun.com.A goat = new sun.com.A();

10.访问权限

访问限制修饰符有private、protected和public，他们都是Java关键字，用来修饰成员变量或方法。

ps：一个类中的实例方法总是可以操作该类中的实例变量和类变量；类方法总是可以操作该类中的类变量，与访问限制修饰符无关。

10.1私有变量和私有方法

用关键字private修饰成员变量和方法。

对于私有成员变量或方法，只能在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法。

例如：
 

calss Tom{
    private float weight;
    private float f(float a,float b){
        return a+b;
    }
}

class Jerry{
    void g(){
        Tom cat = new Tom();
        cat.weight=23f;            //非法
        float sum = cat.f(2,3);    //非法
    }
}

当在另外一个类中用类Tom创建了一个对象后，该对象不能访问自己的私有成员变量和方法。

10.2公有变量和公有方法

用public关键字修饰的成员变量和方法。

例如：

calss Tom{
    public float weight;
    public float f(float a,float b){
        return a+b;
    }
}

class Jerry{
    void g(){
        Tom cat = new Tom();
        cat.weight=23f;            //合法
        float sum = cat.f(2,3);    //合法
    }
}

把private换成public就全部合法了。

10.3友好变量和友好方法

不用private、public、protected修饰符的成员变量和方法，也叫缺省。

例如：

calss Tom{
    float weight;
    float f(float a,float b){
        return a+b;
    }
}

class Jerry{
    void g(){
        Tom cat = new Tom();
        cat.weight=23f;            //合法
        float sum = cat.f(2,3);    //合法
    }
}

在任何一个与Tom同一个包的类中，也可以通过Tom类的类名访问Tom类的友好成员变量和友好方法。

10.4受保护的成员变量和方法

用protected修饰的成员变量和方法。

例如：

calss Tom{
    protected float weight;
    protected float f(float a,float b){
        return a+b;
    }
}

class Jerry{
    void g(){
        Tom cat = new Tom();
        cat.weight=23f;            //合法
        float sum = cat.f(2,3);    //合法
    }
}

10.5 public类与友好类

如果在关键字class前面加上public关键字，就称之为public类：

public class A{

....

}

可以在任何另外一个类中，使用public类创建对象。

如果不加public，被称为友好类

class A{

...

} 

 那么在另外一个类中使用友好类创建对象时，要保证它们在同一个包中。

ps:1.不能用protected和private修饰类。

2.访问限制修饰符按访问权限从高到低的顺序是：public、protected、private、

11.基本数据类型的类封装

11.1Double和Float类

Double类和Float类实现了对double和float基本数据类型数据的类封装。

Double类的构造方法：
Double(double num)

创建一个Double类型的对象；

使用Float类的构造方法：

 Float(float num)

创建一个Float类型的对象。Double对象调用doubleValue()方法可以返回该对象含有的double型数据；float同。

11.2Byte、Short、Integer和Long型

下述构造方法分别可以创建Byte、Short、Integer、Long类型的对象：

Byte(byte num)

Short(short num)

Integer(int num)

Long(long num)

 Byte、Short、Integer、Long对象分别调用byteValue()、intValue()、shortValue()、longValue()方法返回该对象含有的基本类型数据。

11.3Character类

Character类实现了对char基本类型数据的类封装。

Character类的构造方法：

Character(char c)

 Character对象调用charValue()方法返回该对象含有的基本类型数据。