Java面向对象-认识类和对象

FreedomLifepa

于 2024-02-19 16:49:45 发布

阅读量968

点赞数 23

文章标签： java python 开发语言

本文链接：https://blog.csdn.net/FreedomLifepa/article/details/136171847

版权

本文详细介绍了Java面向对象编程中的类与对象概念，包括它们之间的关系、如何创建类和对象、定义属性和方法，以及对象的创建、赋值、调用属性和方法的过程。

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

认识类和对象

文章目录

认识类和对象
前言
一、类与对象的关系
二、类
三、对象
四、方法

前言

在认识类和对象的过程中，我们需要掌握类和创建对象的关系、如何定义类和对象以及定义和调用方法

一、类与对象的关系

在Java面向对象中，类就是图纸，分为：

属性：这一类事物拥有的共同属性

动作：这一类事物共同执行的功能

而对象：是使用类创建的具体某一个东西，对象能干什么完全取决于类是如何定义的

二、类

1、创建类

（1）语法格式

访问修饰符 class 类名 {}

说明：

访问修饰符可以写成public（公共的）、默认的（什么单词都不写）

类名要使用大驼峰命名法、做到见名知意

public class Student {}

2、在类中定义属性

（1）语法格式

访问修饰符 数据类型 属性名

说明：

1）属性的访问修饰符有如下4个：

默认的，什么也不写，也不用写default

public：公共的

private：私有的

protected：受保护的

2）数据类型可以是8大基本数据类型，也可以是3大引用数据类型

3）属性名的命名规则与变量命名规则一样

public class Student {
	public String name;
	public int age;
	public char gender;
	public double height;
	public double weight;
}

3、在类中定义方法

（1）语法格式

访问修饰符 返回值类型 方法名(数据类型 参数名1,数据类型 参数名2,...,数据类型 参数名n){
               //方法体代码
}

说明：

1）方法的访问修饰符可以有如下4种：

默认的，什么也不写，也不用写default

public：公共的

private：私有的

protected：受保护的

2）返回值类型：

描述执行方法得到结果的类型，可以是8大基本数据类型，也可以是3大引用数据类型

方法也可以没有返回值，没有返回值的时候，返回值类型写void（空）

3）方法名：使用小驼峰命名法，见名知意

4）参数列表：(数据类型参数名1,数据类型参数名2,…,数据类型参数名n)

执行这个方法需要的参数，可以没有，那么(数据类型参数名1,数据类型参数名2,…,数据类型参数名)就省略不写

如果方法需要参数，就按照规则定义参数列表即可

5）方法体代码：方法体代码描述的是方法要执行功能的代码

public class Student {

	// 定义属性
	public String name;
	public int age;
	public char gender;
	public double height;
	public double weight;
	
	// 定义方法
	public void printStudentInformation() {
		System.out.println("学生姓名："+name);
		System.out.println("学生年龄："+age);
		System.out.println("学生性别："+gender);
		System.out.println("学生身高："+height);
		System.out.println("学生体重："+weight);
	}
}

三、对象

1、创建对象

（1）语法格式

类名 对象名 = new 类名();

public class StudentTest {
	public static void main(String[] args) {
		// 类是一个模板，根据模板来创建对象
		// 创建对象的语法规则：类名 对象名 = new 类名();
		Student student1 = new Student();
        // 直接输出创建的对象
        System.out.println(student1); // 输出结果 object.Student@1b6d3586
	}
}

2、创建对象赋值

（1）语法格式

对象名.属性名 = 数据;

// 给创建的对象的属性赋值：对象名.属性名 = 数据;
        student1.name = "大鹏";
        student1.age = 21;
        student1.gender = '男';
        student1.height = 180;
        student1.weight = 75;

3、通过对象调用属性

// 通过对象调用属性：对象名.属性名
		System.out.println(student1.name); // 输出结果 大鹏
        System.out.println(student1.age); // 输出结果 21
        System.out.println(student1.weight); // 输出结果 75.0
        System.out.println(student1.height); // 输出结果 180.0

4、通过对象调用方法

// 通过student1对象调用方法printStudentInfo输出对象信息
// 对象名.方法名();
        student1.printStudentInformation();

5、总结

public class StudentTest {
	public static void main(String[] args) {
		// 创建第二个Student对象
        Student student2 = new Student();
        
        // 给对象student2属性赋值
        student2.name = "如花";
        student2.age = 16;
        student2.gender = '男';
        student2.height = 190;
        student2.weight = 190;
        
        // 输出student2对象的属性值
        System.out.println(student2.name);
        System.out.println(student2.age);
        System.out.println(student2.gender);
        System.out.println(student2.height);
        System.out.println(student2.weight);
        
        // 通过student2对象调用方法输出对象属性信息
        student2.printStudentInformation();
	}
}

四、方法

1、方法的定义

根据方法是否有返回值，将方法分为无返回值的方法和有返回值的方法

1）无返回值的方法，返回值类型写void

2）有返回值的方法，返回值类型写返回数据的类型

有返回值的方法，需要通过return关键字返回指定的数据类型

public class MethodDemo01 {

    // 定义一个无返回值的方法
    public void m1(){
        System.out.println("m1()是一个无返回值的方法");
    }

    // 定义一个返回int类型数据的方法m2()
    // 定义有返回值需要用return关键字返回指定的数据类型
    // 不写return则会报错
    public int m2(){
        int num = 300;
        return num;
    }

    // 定义一个返回String类型数组的方法
    // 返回值可以是8大基本数据类型，也可以是3大引用数据类型
    public String[] m3(){
        String[] strs = {"qwert","asdfg"};
        return strs;
    }
}

public class MethodDemo01Test {

    public static void main(String[] args) {

        // 创建MethodDemo01对象
        MethodDemo01 methodDemo01 = new MethodDemo01();
        // 调用无返回值的方法m1
        // 调用没有返回值的方法时，直接调用方法，不需要再做其他任何操作
        methodDemo01.m1();

        // 调用有返回值的方法m2
        // 方法返回什么类型的结果，就使用什么类型的变量接收返回值
        int result1 =methodDemo01.m2();
        System.out.println("result1 = "+result1);

        // 不使用变量接收方法返回值，直接将返回值输出
        System.out.println(methodDemo01.m2());

        // 调用有返回值的方法m3
        String[] strings =methodDemo01.m3();
        System.out.println(Arrays.toString(strings));

    }
}

2、无参方法和有参方法

根据方法是否有参数来分类：

1）无参方法：没有参数的方法

2）有参方法：有参数的方法，参数可以是一个或者多个，可以是相同类型的也可以是不同类型的

所以方法最终的表现形式有四种：

1）无返回值的无参方法

2）无返回值的有参方法

3）有返回值的无参方法

4）有返回值的有参方法

方法调用原则：

1）给什么接什么：方法返回什么类型的值，要么直接输出返回值，要么拿对应类型的变量接收返回值

2）要什么给什么：方法需要什么样的参数，按照参数列表的要求传递参数

public class MethodDemo02 {

    // 定义一个无参方法 无返回值
    public void m1(){
        System.out.println("没有参数的方法m1()");
    }

    // 定义一个需要传递一个int类型数据的方法 有参 无返回值
    // num是一个形式参数，简称形参
    public void m2(int num){
        System.out.println("你传递过来的值："+num);
    }

    // 定义一个需要传递两个int类型数据的方法 有参 无返回值
    public void m3(int num1,int num2){
        System.out.println("你传递过来的两个数据之和："+(num1+num2));
    }

    // 定义一个需要传递一个int类型数据和一个double类型数据的方法
    public void m4(int num1,double num2){
        System.out.println("你传递过来的两个数据是："+num1+"，"+num2);
    }

    // 定义一个方法，需要传递一个int类型的数组，然后将传递过来的数组元素进行求和，将结果和返回 有参 有返回值
    public int arraySum(int[] nums){
        // 声明一个变量sum用来累加数组之和
        int sum = 0;
        // 通过循环进行累加
        for(int i =0;i<nums.length;i++){
            sum+=nums[i];
        }
        return sum;
    }
}

public class MethodDemo02Test {

    public static void main(String[] args) {

        // 创建MethodDemo02类对象
        MethodDemo02 methodDemo02 = new MethodDemo02();

        // 调用无参方法：不需要传递参数
        methodDemo02.m1();

        // 调用有参方法，传递一个int类型数据
        methodDemo02.m2(200); // 调用方法时传递的实际参数是200，简称实参
        int a =300; // 定义一个变量并赋值
        methodDemo02.m2(a); // 调用方法时传递的实际参数是a，简称实参
        // methodDemo02.m2(199.99); m2方法需要的是int类型的，你传递的是double类型的数据，不符合参数列表要求

        // 调用有参方法，传递两个int类型数据
        methodDemo02.m3(100,200);

        // 调用有参方法，传递一个int类型数据和一个double类型数据
        methodDemo02.m4(100,99.99);
        //methodDemo02.m4(99.99,100); // 调用有参方法时需要根据参数的类型、个数、顺序传递参数

        // 总结：调用有参方法时，必须按照方法参数列表的数据类型、个数、顺序要求传递参数

        // 定义一个int类型数组
        int[] array1 = {11,22,33};
        int result1 = methodDemo02.arraySum(array1);
        System.out.println("array1数组元素之和："+result1);

        int[] array2 = {11,33,44,55,66};
        System.out.println(methodDemo02.arraySum(array2));

    }
}

3、方法的调用

方法的三种调用方式：

1）通过对象调用方法：在其他类中调用非静态方法

2）通过类名直接调用方法：要求方法使用static修饰，直接通过类名.方法名()

3）在同一个类中，方法之间可以直接调用，无需创建对象或者通过类名调用

非静态方法（没有使用static修饰的方法）既可以调用非静态方法，也可以调用静态方法

静态方法只能调用静态方法

public class MethodDemo03 {

    public void m1(){
        System.out.println("无返回值的无参方法m1()");
    }

    public void m2(){
        System.out.println("无返回值的无参方法m2()");
        m1();
        m3(); // 非静态方法中既可以调用非静态方法，也可以调用静态方法
    }

    public static void m3(){
        System.out.println("使用static修饰的无参回值的无参方法m3()");
    }

    public static void m4(){
        System.out.println("使用static修饰的无参回值的无参方法m4()");
        m3();
        // m1(); 静态方法中只能调用同一个类的静态方法，不能调用非静态方法
    }
}

public class MethodDemo03Test {

    public static void main(String[] args) {

        // 调用方法的方式一：通过对象调用方法
        MethodDemo03 methodDemo03 = new MethodDemo03();
        methodDemo03.m1();

        // 调用方法的方式二：通过类名调用方法
        // 使用static修饰的方法也可以通过对象名调用
        methodDemo03.m3(); // 输出结果 使用static修饰的无参回值的无参方法m3()
        // 类名调用方法
        MethodDemo03.m3(); // 输出结果 使用static修饰的无参回值的无参方法m3()

        System.out.println("--------------------");

        methodDemo03.m2();
        // 输出结果
        // 无返回值的无参方法m2()
		// 无返回值的无参方法m1()
		// 使用static修饰的无参回值的无参方法m3()

        System.out.println("--------------------");

        MethodDemo03.m4(); // 使用类名调用方法
        // 输出结果
        // 使用static修饰的无参回值的无参方法m4()
		// 使用static修饰的无参回值的无参方法m3()

    }
}

4、创建工具类方法

public class MyArrays {

    // 定义操作数组的静态方法，用来操作数组中的元素

    // 定义一个静态方法实现遍历数组
    public static void printArrayData(int[] array) { // static修饰的作用 不用也可以

        // 遍历数组
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[");
            }
            if (i < array.length) {
                System.out.print(array[i]);
            }
            if (i < array.length-1) {
                System.out.print(",");
            }
            if (i == array.length-1) {
                System.out.print("]");
            }
        }
    }
}

public class MyArraysTest {

    public static void main(String[] args) {

        // 定义int类型数组
        int[] nums = {11,56,78,32,45,66,99};

        // 用自己的数组工具类MyArrays中的方法实现遍历数组
        MyArrays.printArrayData(nums);
        // 输出结果 [11,56,78,32,45,66,99]
        
    }
}

FreedomLifepa

关注

23
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象-认识类和对象

在认识类和对象的过程中，我们需要掌握类和创建对象的关系、如何定义类和对象以及定义和调用方法（1）语法格式访问修饰符数据类型属性名说明：1）属性的访问修饰符有如下4个：默认的，什么也不写，也不用写defaultpublic：公共的private：私有的protected：受保护的2）数据类型可以是8大基本数据类型，也可以是3大引用数据类型3）属性名的命名规则与变量命名规则一样（1）语法格式。
复制链接

扫一扫