【Java】Java面向对象与方法

标签：Java Person int void class 面向对象 static 方法 public

1.基本方法

1.1.基本定义

在Java中，方法即为函数，Java中的方法定义遵循下面的通用格式

 修饰符 返回值 方法名 (形参列表){
     方法体
 }
对于基本方法的定义，遵循下面的结构
 
 public static 返回类型 方法名(形参列表){
     方法体
 }

是否需要返回类型和形参列表需要看该函数的功能，具体思路可以参考C/C++中定义函数的方式

 public class Test_method {
     public static void main(String[] args) {
         int ans = add(10, 20);
         System.out.println("ans = " + ans);
     }
 ​
     // 示例方法
     public static int add(int a, int b){
         int sum = a + b;
         return sum;
     }
 }
 ​
 输出结果：
 ans = 30

1.2.数组类型作为参数

如果是数组类型作为方法参数和返回值时，需要注意，在Java中，传递和返回数组都只是传递地址值

 public class Test_method {
     public static void main(String[] args) {
         int arr[] = {10, 20};
         int arr1[] = calculate(arr);
         for (int i = 0; i < arr1.length; i++) {
             System.out.print(arr1[i]+" ");
         }
     }
 ​
     // 数组作为形参和返回值
     public static int[] calculate(int[] arr) {
         int sum = 0;
         int sub = 0;
         for (int i = 0; i < arr.length; i++) {
             sum += arr[i];
             sub -= arr[i];
         }
         int[] arr1 = {sum, sub};
         return arr1;
     }
 }
 ​
 输出结果：
 30 -30

可以类比下面的C语言代码

#include <stdio.h>
 #include <stdlib.h>
 ​
 // 定义calculate函数，返回值为指针类型，参数为指针+输出型参数size（表示数组大小）
 int *calculate(int *arr, int *size)
 {
     int sum = 0;
     int sub = 0;
     for (int i = 0; i < *size; i++)
     {
         sum += arr[i];
         sub -= arr[i];
     }
     // 因为C语言数组是在栈上开辟的，所以不能返回，需要返回时必须使用动态内存开辟
     int *arr1 = (int *)malloc(sizeof(int) * 2);
     arr1[0] = sum;
     arr1[1] = sub;
     // 改变输出型参数值作为返回数组的长度
     *size = sizeof(arr1) / sizeof(int);
     return arr1;
 }
 ​
 int main()
 {
     int arr[2] = {10, 20};
     int size = sizeof(arr) / sizeof(int);
     int *arr1 = calculate(arr, &size);
     for (int i = 0; i < size; i++)
     {
         printf("%d ", arr1[i]);
     }
     return 0;
 }
 ​
 输出结果：
 30 -30

1.3.方法重载

Java同C++一样，也支持方法重载，并且方式相同

重载前提：方法名相同

重载要求：

1. 参数个数不同

2. 参数类型不同

3. 在参数个数相同，参数类型不同的情况下，参数顺序不同

满足上面任意一个条件即可构成函数重载

// 定义基础方法
 public static void test(){}
 // 下面函数与基础方法可以构成重载
 public static void test(int a){}// 可以
 public static void test(int a,int b){}// 可以
 public static void test(double a,int b){}// 可以
 public static void test(int a,double b){}// 可以
 // 下面情况不可以
 public static void test(int i,double d){}// 不可以
 public static void TEST(){}// 不满足重载前提
 public static void test(int i,int j){}// 不可以
 public static int test(int a, int b){}// 不可以

2.类和对象

2.1类

创建类：

在Java中，使用class关键字创建类，建议一个类作为一个单独的文件

一般称成员变量为属性，称成员函数为方法

例如，Person类

 public class Person {
     // 属性
     String name;
     int age;
 ​
     // 方法，不使用static关键字
     public void speak(){
         System.out.println("说话");
     }
 }

2.2.成员变量（属性）和局部变量的区别

成员变量和局部变量有以下的区别：

1. 定义位置不同

   1. 成员变量定义在方法外，类内，整个类中都可以被访问

   2. 局部变量定义在方法内，只能在当前最近的作用域中访问

2. 初始化值不同

   1. 成员变量有默认值，默认值参考数组中的类型默认值

   2. 局部变量没有默认值

1. 内存位置不同

   1. 成员变量预备在方法区，实际使用时在堆区

   2. 局部变量在栈区

2. 生命周期不同

   1. 成员变量的生命周期随着变量的创建而创建，随着其销毁而销毁

   2. 局部变量的生命周期随着当前作用域的销毁而销毁

2.3.对象

创建对象：

在Java中，创建对象需要使用new关键字，使用new创建出来的对象都在堆区 例如，创建Person类对象

如果两个类在同一个包下，则再另一个类中使用当前类创建对象时不需要引包操作，否则需要使用import关键字引包

特殊地，Java中的lang包不需要单独引包

同一包下的Person类
package com.lze.java_class;
public class Person {
    // 属性
    String name;
    int age;
 
    // 方法
    public void print(){
        System.out.println("name = " + name + " " + "age = " + age);
    }
}
 
同一包下的测试类
package com.lze.java_class;
 
public class Java_class {
    public static void main(String[] args) {
        // 创建Person类对象
        Person p = new Person();
        // 访问Person中的成员
        p.age = 12;
        p.name = "张三";
        p.print();
    }
}
 
输出结果：
name = 张三 age = 12

两个不同对象的内存分析:

以Person类的两个对象进行分析

public class Person {
    // 属性
    String name;
    int age;
 
    // 方法
    public void print(){
        System.out.println("name = " + name + " " + "age = " + age);
    }
}
 
public class Java_class {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.age = 10;
        p1.name = "张三";
        p1.print();
        Person p2 = new Person();
        p2.age = 20;
        p2.name = "李四";
        p2.print();
 
    }
}

首先，Person类中的属性和方法以及测试类的方法都会加载到方法区进行预备，此时每一个类都会有一个class 地址值

接着，main方法执行，加载到栈区，创建出对象p1和p2，因为是new为对象开辟的空间，所以该空间在堆上，p1和p2分别存储这两个堆上空间的地址，并且在两个对象空间中，都存在着class地址值，当类相同时，class地址值也是相同的，该地址值用于查询到类中的方法，执行print时加载print方法进入栈区

匿名对象：

在Java中，也可以创建匿名对象，前面创建对象的步骤为类名 对象名 = new 类名()，那么匿名对象即为去无赋值符左边部分new 类名()

public class Java_class {
    public static void main(String[] args) {
        // 创建Person类匿名对象调用函数
        new Person().print();
    }
}

一般在只需要调用函数时创建匿名对象，每一次匿名对象的创建都是重新开辟一块空间

2.4.类和对象练习与链式调用

//Birthday类
package lzastudy;

class Birthday {
    int year;
    int month;
    int day;
}

//Person类
class Person {
    // 属性
    String name;
    int age;
    Birthday birthday;

    // 方法
    public void print(){
        System.out.println("name = " + name + " " + "age = " + age + " " + "birthday: " + birthday.year + "/" + birthday.month + "/" + birthday.day);
    }
}

//测试类
public class Brithday {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Peter";
        p.age = 20;
        // 因为Birthday是引用数据类型，所以默认是null，不可以直接调用year等成员，否则会出现空指针问题，需要先创建Birthday对象
        p.birthday = new Birthday();
        // 接着再为Birthday类对象赋值
        p.birthday.year = 2000;
        p.birthday.month = 10;
        p.birthday.day = 25;
        p.print();
    }
}

//输出结果：
//name = Peter age = 20 birthday: 2000/10/25

标签：Java,Person,int,void,class,面向对象,static,方法,public
From： https://blog.csdn.net/2301_79582015/article/details/143024436