【JavaSE】类和对象

lzhao妮

已于 2023-11-30 14:39:38 修改

阅读量81

点赞数

文章标签： java jvm 开发语言

于 2023-03-04 22:43:57 首次发布

本文链接：https://blog.csdn.net/weixin_49098230/article/details/129339086

版权

本文介绍了Java编程中的类和对象的概念，强调了类作为模板和对象作为实例的角色。文章详细讲解了类的成员，包括字段和方法，以及如何通过private关键字实现封装。还讨论了构造方法在对象实例化过程中的作用，以及不同类型的代码块（普通、构造、静态）。最后，文章提供了课后作业，帮助读者巩固所学知识。

摘要由CSDN通过智能技术生成

1.类和对象的初步认知

类就是一类对象的统称。对象就是这一类具体化的一个实例。

简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象, 所以月饼就是一个实体。 一个模子可以实例化无数个对象。

总的来说：类相当于一个模板，对象是由模板产生的样本。 一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在 Java 中属于 引用类型 ， Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类。

基本语法:

// 创建类

class < class_name > {

field ; // 成员属性

method ; // 成员方法

}

// 实例化对象

< class_name > < 对象名 > = new < class_name > ();

class 为定义类的关键字， ClassName 为类的名字， {} 中为类的主体。

类中的元素称为：成员属性。类中的函数称为：成员方法。

注意事项

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

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

同一个类可以创建对多实例

类是如何实例化的？

2. 类的成员

2.1 字段/属性/成员变量

1.字段-》属性-》成员变量普通成员变量

静态成员变量

其中普通成员变量是属于对象的，需要通过new以后才能访问

而静态成员变量（用static修饰）是属于类的，可以直接用类名+点操作符访问。

例子如下：

class People{
    //普通成员变量-属于对象的
    public String name="heh";
    //静态成员变量-属于类的-不需要对象就可以调用
    public static int age=19;
}

public class TextDemo {

public static void main(String[] args) {
        People people = new People();
        people.name="nini";//name是普通成员变量，是属于对象的，需要实例化以后才能访问
        System.out.println(people.name);
        People.age=10;//静态成员变量可以通过类名直接访问
        System.out.println(People.age);
    }
}

运行后的结果如下：

静态的成员变量存在于方法区，是只有一份的，对其改变以后的结果会保存下来。

class People{
    public static int age=19;//静态成员变量
}
public class TextDemo {

    public static void main(String[] args) {
        People.age++;//静态成员变量可以通过类名直接访问
        System.out.println(People.age);
        People.age++;
        System.out.println(People.age);
    }
}

运行结果：
20
21

2.2 方法 (method)

关于方法我们有几点需要注意的：

1.普通的方法内部不能够定义静态的变量。

2.静态方法内部不可以调用普通方法

3.普通方法内部可以调用静态方法

理由同上图

3.关于引用

4.封装

什么叫封装 ?

<< 代码大全 >> 开篇就在讨论一个问题 : 软件开发的本质就是对程序复杂程度的管理 . 如果一个软件代码复杂程度太高, 那么就无法继续维护 . 如何管理复杂程度 ? 封装就是最基本的方法 .

在我们写代码的时候经常会涉及两种角色 : 类的实现者 和 类的调用者 .

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的 , 只要知道如何使用类就行了 .

这样就降低了类使用者的学习和使用成本 , 从而降低了复杂程度

4.1用private来实现封装

4.2用private修饰字段

当我们使用 private 来修饰字段的时候 , 就无法直接使用这个字段了 .

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

5. 构造方法

构造方法是一种特殊方法 , 使用关键字 new 实例化新对象时会被自动调用 , 用于完成初始化操作（构造方法是用来构造对象的，没有构造方法是实例化不了的）

new 执行过程分为两步

1.为对象分配内存空间

2.调用对象的构造方法

语法规则

1. 方法名称必须与类名称相同

2. 构造方法没有返回值类型声明

3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项：

1.如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数；

2.若类中定义了构造方法，则默认的无参构造将不再生成；

3.构造方法支持重载。

代码示例

class People{
   private static int age=19;

   //默认构造函数
    public People(){
        this.age=29;
        System.out.println("这是调用了不带参数的构造函数");
    }
    //带一个参数的构造函数
    public People(int age){
        this.age=age;
        System.out.println("这是调用了带1参数的构造函数");
    }

}
public class TextDemo {

    public static void main(String[] args) {
      //调用不带参数的构造函数，如果程序没有系统会提供一个不带参数的构造函数
      People people = new People();
      //调用不带1参数的构造函数
      People people2 = new People(19);
    }
}

运行结果：
        这是调用了不带参数的构造函数
        这是调用了带1参数的构造函数

6. 认识代码块

6.1 什么是代码块

使用 {} 定义的一段代码就叫代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块

6.2 普通代码块

普通代码块：定义在方法中的代码块

6.3 构造代码块

构造块：定义在类中的代码块 ( 不加修饰符 ) 。也叫： 实例代码块 。构造代码块一般用于初始化实例成员变量。

6.4 静态代码块

使用 static 定义的代码块。 一般用于初始化静态成员属性。

注意事项

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

代码示例如下：

class People{
   private static int age=19;

    {
        System.out.println("这是实例代码块");
    }

    static{
        System.out.println("这是静态代码块");
    }

   //默认构造函数
    public People(){
        this.age=29;
        System.out.println("这是调用了不带参数的构造函数");
    }
    //带一个参数的构造函数
    public People(int age){
        this.age=age;
        System.out.println("这是调用了带1参数的构造函数");
    }

}
public class TextDemo {

    public static void main(String[] args) {
      //调用不带参数的构造函数，如果程序没有系统会提供一个不带参数的构造函数
      People people = new People();
        System.out.println("========================");
      People people2 = new People();
    }
}
运行结果：
        这是静态代码块
        这是实例代码块
        这是调用了不带参数的构造函数
        ========================
        这是实例代码块
        这是调用了不带参数的构造函数

7.课后作业

编写一个类 Calculator, 有两个属性 num1,num2, 这两个数据的值，不能在定义的同时初始化，最后实现加减乘除四种运算.

class Calculator{
        private int num1;
        private int num2;

       public void setNum(int num1,int num2){
           this.num1=num1;
           this.num2=num2;
       }
       //add
        public int getAdd(){
           return num1+num2;
       }
       //sub
       public int getSub(){
        return num1-num2;
       }
       //mcl
       public int getMcl(){
           return num1*num2;
       }
       //div
       public double getDiv(){
           return num1*1.0/num2;
       }
}

设计一个包含多个构造函数的类，并分别用这些构造函数来进行实例化对象。

class sturctClass{

    sturctClass(){
        System.out.println("这是不带参数的构造方法");
    }
    sturctClass(int age){
        System.out.println("这是不带1个参数的构造方法");
    }
    sturctClass(int age,String name){
        System.out.println("这是不带2个参数的构造方法");
    }
}
public class TextDemo {
    public static void main(String[] args) {
        sturctClass sturctClass = new sturctClass();
        sturctClass sturctClass2 = new sturctClass(10);
        sturctClass sturctClass3 = new sturctClass(10,"nini");
    }
}

运行结果：
这是不带参数的构造方法
这是不带1个参数的构造方法
这是不带2个参数的构造方法

实现交换两个变量的值。要求：需要交换实参的值。

用类和对象来实现，代码如下：

class MyValue{
      public int num;
}
public class TextDemo {
//交换函数
     public static void swap(MyValue myVal1,MyValue myVal2){
         int temp = myVal1.num;
         myVal1.num = myVal2.num;
         myVal2.num = temp;
     }

    public static void main(String[] args) {
        //实现交换两个变量的值。要求：需要交换实参的值。
        MyValue myValue1 = new MyValue();
        MyValue myValue2 = new MyValue();
        myValue1.num=10;
        myValue2.num=20;
        System.out.println("交换前");
        System.out.println("myValue1.num="+myValue1.num+" "+"myValue2.num="+myValue1.num);
        swap(myValue1,myValue2);
        System.out.println("交换后");
        System.out.println("myValue1.num="+myValue1.num+" "+"myValue2.num="+myValue1.num);

    }
}