Java 的类和对象

目录

Java 类和对象

认识类

一、  什么是类？

二、 如何创建类？

三、 成员变量

四、实例化对象

2.1 什么是对象？

2.2 实例化一个对象

2.3方法（mathod）

2.4 static 关键字

1）修饰属性

 2） 修饰方法

2.5 小结

五、封装

5.1 private 实现封装

5.2 getter 和 setter 方法

---

Java 类和对象

认识类

一、  什么是类？

类就是用来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为

二、 如何创建类？

三、 成员变量

只要是定义在类里，方法外的变量都可以称为成员变量，"成员变量"也可以称为 "字段" 或 "属性" 或 (三种称呼都可以, 一般不会严 格区分).

class Person {
    public String name;   // 字段

    public int age;
}

class Test {
    public static void main(String[] args) {
 

注意事项
使用 . 访问对象的字段.
"访问" 既包含读, 也包含写.

对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值.

默认值规则
对于各种数字类型, 默认值为 0.

对于 boolean 类型, 默认值为 false.

对于引用类型(String, Array, 以及自定制类), 默认值为 null

 

认识 null
null 在 Java 中为 "空引用", 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常.
 

字段就地初始化
很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样写:

        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
   }
}

// 执行结果
null
0

注意事项

使用 . 访问对象的字段.

"访问" 既包含读, 也包含写.

默认值规格

成员变量在定义时未进行初始化，就会被设置成一个默认的值

默认值规格

•         数值类型 （int ， double 等），默认值为0
•         boolean 类型，默认值为false
•         对于引用类型 （如 Array , String ）,默认值为null

四、实例化对象

2.1 什么是对象？

我们通过 类 实例出来的 就是 对象

如下图 一个房子图纸（类） 创建（实例）出来的 房子 我们就称之为对象

一个类可以实例多个对象

 

2.2 实例化一个对象

基本语法

类名 对象名 = new 类名（参数列表）；

// 创建类

public class Student {

    public String name = "张三";
    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
}

// 实例化对象

public class Text {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.name);
        student.sleep();
    }
}

2.3 实例多个对象

如图所示

我们通过类（模版）实例化出了多个对象（student1，student2，student3）

我们在通过对象，可以调用当前对象的普通成员方法和普通成员变量

2.3方法（mathod）

用于描述一个对象

sleep 就是一个方法 ，来描述 对象正在水箱

2.4 static 关键字

static 的作用

1、可以修饰属性

2、可以修饰方法

3、可以修饰代码块

4、可以修饰类

1）修饰属性

Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性

示例

//定义类
public class Student {
    public static String name;
    public static int age;
}
//定义main
public class Text {
    public static void main(String[] args) {
        System.out.println(Student.name);
        System.out.println(Student.age);
}

//输出结果
null
age

如上图所示

我们未实例化student 对象 ，但是我们却可以直接访问 name 和 age。

小结

• 静态成员变量 存储在 方法区 就不属于成员属性了 静态成员变量成了对象 共有的属性了

       静态成员变量不依赖于对象

• 静态成员方法有另外一种叫法 叫做 类变量 ，静态成员变量的生命周期是跟随类

        但是普通成员变量的生命周期是跟随对象的

• 调用时 类名 . 静态成员变量  就可以了

 2） 修饰方法

如果在任何方法上应用 static 关键字，此方法称为静态方法。

1. 静态方法属于类，而不属于类的对象。

• 可以直接调用静态方法，而无需创建类的实例。
• 静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

class TestDemo{
    public int a;
    public static int count;
    
    public static void change() {
        count = 100;
        //a = 10; error 不可以访问非静态数据成员

   }
}

public class Main{

    public static void main(String[] args) {
        TestDemo.change()；//无需创建实例对象 就可以调用

        System.out.println(TestDemo.count);   
   }
}

输出结果：

100

注意事项1: 静态方法和实例无关, 而是和类相关. 因此这导致了两个情况:

• - 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
• - this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也 是和当前实例相关).

注意事项2

• -我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
• main 方法为 static 方法.

2.5 小结

class Person {
    public int age;//实例变量   存放在对象内

    public String name;//实例变量

    public String sex;//实例变量

    public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区

    public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改

    public static final int  COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更
改

    //实例成员函数

    public void eat() {
       int a = 10;//局部变量 

       System.out.println("eat()!");  
   }
    //实例成员函数 

    public void sleep() {
       System.out.println("sleep()!");  
   }
    //静态成员函数

     public static void staticTest(){
         //不能访问非静态成员

        //sex = "man"; error

        System.out.println("StaticTest()");
     }
}

public class Main{
 public static void main(String[] args) {
输出结果为：
数据属性的内存布局：

        //产生对象 实例化对象

        Person person = new Person();//person为对象的引用

        System.out.println(person.age);//默认值为0

        System.out.println(person.name);//默认值为null

        //System.out.println(person.count);//会有警告!

        //正确访问方式：

        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。

        person.eat();
        person.sleep();
 }
}

输出结果为：

0

null

0

99

StaticTest()

eat()!

sleep()!

数据属性的内存布局：

五、封装

• 什么叫封装? 代码大全>> 开篇就在讨论一个问题: 软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程 度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.
• 在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
• 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
• 这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度.

• 更直白的说，我们把类比作空调，我们通过空调外壳将空调内部结构保护（封装）起来，我们只需要给用户提供一个空调遥控器（接口）给用户来控制（调用）空调即可。
• 用户无需关心空调内部的具体实现原理，我们通过遥控器给用户提供接口，降低了用户使用成本，我们将空调内部封装起来，也是保护我们的空调（程序），使我们的程序更安全了。

5.1 private 实现封装

private/ public 这两个关键字表示 "访问权限控制" .

• 被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
• 被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.

换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的 成本来使用类.

直接使用 public

class Person {
 public String name = "张三";
 public int age = 18;
}

class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
   }
}

执行结果

我叫张三, 今年18岁

• 这样子的代码，不是很好的代码，当用户需要调用Person类的时，用户需要了解Person类的结构和成员变量。
• 这样子的代码提高了用户的使用门槛，也不方便我们后续对代码的维护。

示例 使用private封装成员变量，并且提供public修饰方法供给用户使用

class Person { 
     private String name = "张三"; 
     private int age = 18; 
 
     public void show() { 
         System.out.println("我叫" + name + ", 今年" + age + "岁"); 
     } 
} 
 
class Test { 
     public static void main(String[] args) { 
         Person person = new Person(); 
         person.show(); 
     } 
} 

执行结果 

我叫张三, 今年18岁

• 此时 成员变量只允许用过show方法来调用，用户是不能直接使用name 和 age的
• 同时如果类的构造者修改了成员变量名字，用户无需做出任何修改（用户无法访问到name 和
• age 这些被private 封装起来的方法）

那么问题来了~~ 类的实现者万一修改了 public 方法 show 的名字, 岂不是类的调用者仍然需要大量修改代码 嘛?

这件事情确实如此, 但是一般很少会发生. 一般类的设计都要求类提供的 public 方法能比较稳定, 不应该频繁发 生大的改变. 尤其是对于一些基础库中的类, 更是如此. 每次接口的变动都要仔细考虑兼容性问题.

注意事项

• private 不光能修饰字段, 也能修饰方法 通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要根据业务场景来决定了。
• 一般我们希 望一个类只提供 "必要的" public 方法, 而不应该是把所有的方法都无脑设为 public。

5.2 getter 和 setter 方法

不知道各位在看上面的代码时 有没有疑问，类的缔造者将 name 和 age 封装了起来，只允许show方法来输出name 和 age，但用户无法对 name 和 age 做出任何改变。

那我们只允许使用缔造者设置的默认值吗？

这是不现实的

所以，我们可以提供 getter（读） 和 setter（写） 这两发方法，来供用户对封装起来的成员变量来进行读写。

代码示例

class Person { 
     private String name = "张三"; 
     private int age = 18; 
 
     public void show() { 
         System.out.println("我叫" + name + ", 今年" + age + "岁"); 
     } 
} 
class Test { 
     public static void main(String[] args) { 
         Person person = new Person(); 
         person.age = 20; 
         person.show(); 
     } 
}

编译出错

Test.java:13: 错误: age可以在Person中访问private

        person.age = 20;

                        ^ 1 个错误

此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法.

5.3  实现 getter 和 setter 方法

我们可以提供 getter（读） 和 setter（写） 这两发方法，来供用户对封装起来的成员变量来进行读写。

其实ider 中有快捷方式，给我们快速事项getter和setter方法

此时，我们就提供getter 和setter方法了

现在返回到刚才的代码

将之前的错误代码改成ider新生成的set方法

此刻 我们通过ider 生成的set 方法就可以对private 封装起来的成员变量的值进行更改/读取了