Java学习14-- 面向对象学习 2.method方法+constructor构造器解析-CSDN博客

本文链接：https://blog.csdn.net/weixin_42892630/article/details/136001201

面向对象学习 2.方法（复习）


- 方法method的定义
- - 修饰符
- - 返回类型
- - break和return的区别  
- - 方法名 （起名尽量规范，见名知意，省的自己下次见了看不懂）
- - 参数列表（参数类型，参数名）最后一个参数可以写成可变类型...
- - 异常抛出（先跳过，后面再说）

- 方法的调用:(一个有自己功能的小模块，比如前面讲过的 递归阶乘计算小模块)
- - 静态方法 static
- - 非静态方法
- - 形参和实参
- - 值传递和引用传递
- - this关键字

方法method的定义

method就是仅在召唤时候才动弹的代码块，可以喂给它data或者parameter，也可以不让他有任何返回值；有特定功能的method叫做function

修饰符:比如这个public static void main其中的public static就是修饰符
返回类型:比如这个public static void main其中的void表示返回值为空,如果这里不是void而是int那么返回值就是int类型的

举例

public class testjan05{
//定义了一个叫做testjan05的class
    public static void main(String[] args) {
//class里面最常用，也是系统自带的一个方法，叫做main方法
// 一般一個class里只有一个main方法
//void表示没有返回值，如果将void换成int,那么表示返回值是一个int

     int m = 5;
     int n = 6;

        System.out.println(m+"和"+n+"比较大的是"+max(m,n));
        prt_max(m,n);
    }

    /**method结构--有返回值
     * 修饰符 返回值类型 方法名(可选参数){
     *     //方法体（干活的程序部分）
     *     return 返回值；
     * }
     *
     *
     * method结构--有返回值
     * 修饰符 void method_name(可选参数){
     * //方法体（干活的程序部分）
     * //直接不写return或者写成return null;
     * }
     *
     *
     */

    //有返回值的method举例 名叫max
    public static int max(int a, int b) {
        return (a>b)? a:b;//三元运算符,如果a>b则返回a,否则返回b
    }

    //没有返回值的method名叫prt_max,虽然没有返回值在执行中会print一些句子
    public static void prt_max(int a, int b) {
        if (a>b){
            System.out.println(a+" is bigger");}
        else if (a==b) {
            System.out.println(a+" equals "+b);
            }
        else System.out.println(b+" is bigger");

    }
}

执行结果

5和6比较大的是6
6 is bigger

Process finished with exit code 0

break和return的区别
break代表跳出switch或者循环
return代表method方法结束了，return之后不能再有命令语句了，如果return后,还继续写其他语句那是会报错的
法名（起名要规范，见名知意,免得自己过了三天就看不懂程序了）
参数列表（参数类型，参数名）这里最后一个参数可以写成可变类型…(具体可参考["可变参数"部分的讲解])

复习:可变参数(参数为不定项)  
    使用方法为某参数类型加三个点,比如int/double后面直接加上省略号...三个点，不要有空格。然后加自定义的变量名.注意一个方法只能指定一个可变参数，必须是方法的最后一个参数，其他普通的参数要在他之前声明。

比如 public static void printmax(int a, int, b double...numbers){... return xxx;}

举例 定义一个接收两个int和一些不定数量的double的method名叫printmax，int数量确定是两个,double的数量不确定。

异常抛出（比如前面可能遇见的数组下标越界错误，后面会再详解）

方法method的调用

(method方法,是一个有自己功能的小模块，比如前面讲过的递归阶乘计算小模块)分为静态static和非静态

静态方法 static
非静态方法(调用口诀:先抓class名,再抓method名)

举例： static和non-static调用举例
注意下面的例子一个public class就是一个java文件,下面的举例涉及到两个文件

知识补充:
一个java文件里面只能有一个public class但是可以有多个class,为了方便理解,下面的举例一个public class写成一个文件

package oop;

public class Demo02 {

//静态方法有static
    public static void main(String[] args) {

        student.say1();//写了static静态方法 可以直接调用
        
             //非静态方法没写static
        //非静态方法，不可直接调用 student.say2();发现报错
        //非静态方法，解决方案：用new将这部分method从其对应的class开始实例化，
		//两种写法都可以,主要是new student().say2()

        new student().say2();//方法一:用new从class开始实例say2这个method,一条写完

        student x =new student();//方法二:用new从class开始实例say2这个method,分两条写完
        x.say2();
    }

}

package oop;

public class student {//学生类

    public static void say1(){//静态方法
        System.out.println("学生static说话了");
    }

    public void say2(){//非静态方法
        System.out.println("学生2说话了");
    }
}

运行结果

学生static说话了
学生2说话了
学生2说话了

再看这个简单的,没有写static,非静态方法调用的例子
本例没有static还能调用成功,全靠下面这个new命令先在main方法中,将另一个文件名叫non_s的class呼唤出来,然后又利用non_s()调用到了non_s.pet(),否则是肯定调用不成的
当然,如果直接写这么一条new non_s().pet();也能调用成功

package oop;

public class Demo04 {
    public static void main(String[] args) {
        non_s my_ns = new non_s();
        my_ns.pet();

    }
}

调用部分

package oop;

public class non_s {
    public void pet() {
        System.out.println("this is a dog");
    }
}

输出

this is a dog

形参和实参
很好理解,比如写了一个method 叫做add(int m, int n),这里的m,n就是形式参数,
在真正调用这个method add时,用了语句add(7,8),这里的7和8是实际参数,m和n只是一个形式参数象征符号,换成x和y也一样能干活,m和n并不是实际参数.
值传递和引用传递(java里面都是值传递的)
简单的说一个没有返回值的method叫做 change(int a),任凭在method内部给这个a各种操作都没用,只要这个method没有返回值,在method外,其他参数谁也没改变.因为没有return,所以值没有传递出来

值传递举例

package oop;
//值传递，java都是值传递
public class Demo04 {
    public static void main(String[] args) {

        int b =1;
        System.out.println("b= "+b);

        Demo04.change(b);
        System.out.println("b= "+b);
    }

    //返回值为空
    public static void change(int a){
        //这里的a只是一个形式参数，它叫做a或m都无所谓
		//而这个叫做change的method并没有返回值，
        //既然change method没有返回值，就改变不了外部main方法里b的数值了
		//下面的 a=10就是在change方法里面短暂的运行了一下下,改变不了外面
        a=10;
    }


}

引用传递举例:

这里传递的不是一个单纯的值,而是一个定义为person class类型的叫做x的object,它包括属性age name 和gender,调用change method的时候,在change method内部改变了x下面一个属性的具体值,所以虽然没有返回值,但是这个叫做x的object在经过change method调用时候,随着追溯x下面name属性的位置,从而name具体的值被改变了.从微观角度来讲,这还是值传递.

== java没有引用传递,都是值传递==

package oop;
//引用传递：对象
//本质还是值传递
public class Demo05 {
    public static void main(String[] args) {

        Person x= new Person();
        System.out.println(x.name);//目前值是null


        Demo05.change(x);
        System.out.println(x.name);
    }

    public static void change(Person p) {
        //p是一个对象，指向的是下面的Person类,而不是一个具体数值
        //p是一个用new新建的,Person类的人(这一句定义的Person x= new Person())
		//p指向一个构造.结构有name age 和 gender,
		//下面这句p.name就是随着p的构造,寻到了p.name保存的地址
		//所以一旦执行,p.name就被改变了
        p.name="brit";

    }
}

//定义了一个Person类，有一个属性：name
class Person{
    String name;
    int age;
    String gender;
}

复习:类class和对象object的关系

class类是一种抽象的数据类型，他是对某一类事物整体描述，不能代表某个具体事物object。比如person,pet,car类。
对象是抽象概念的具体实例，张三就是一个具体实例。旺财也是一个具体实例。

使用new关键字创建对象

使用new关键字创建的时候，除了分配空间外，还会给创建好的对象进行默认的初始化以及对类class中构造器的调用。

this关键字,this代表当前这个class或者当前这个object
- 使用举例如下,比如继承Student类class结构的xiaohong和xiaoming,中间有name和age和gender的field

this关键字使用举例(this关键字使用,后面还会详解)

package oop.Demo02;
//学生类,一个class类里面 最多也就只有属性+方法，不会有其他的了
//养成好习惯 类就是类class，里面不要乱加main方法，一个程序包里面就写一处main方法method即可.

public class Student {
    //属性：字段
    String name;//没有赋值，默认应是null
    int age;//没有赋值，默认应是0


    public void study() {
        System.out.println(this.name+"在学习");
        //这里的this,代表当前这个class类-Student
    }

}

联合Appllication作为主程序

package oop.Demo02;
//一个项目应该只存在一个main方法
//每一个java文件只写一个public class
public class Application {

    public static void main(String[] args) {
        //类class是抽象的，需要实例化
        Student xiaohong= new Student();
        Student xiaoming= new Student();
        //对象xiaohong和xiaoming就是一个Student类的具体实例

        System.out.println("====赋值前====>");
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaoming.name="小明";
        xiaoming.age= 18;

        System.out.println("====小明赋值后====>");
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaoming.study();

    }

}

输出结果为

====赋值前====>
null
0
null
0
====小明赋值后====>
null
0
小明
18
小明在学习

Process finished with exit code 0

constructor构造器
什么是constructor
A constructor in Java is a special method that is used to initialize objects. The constructor is called when an object of a class is created. It can be used to set initial values for object attributes.

从上面的解释可以看出constructor构造器其实就是一种method方法,它是用来初始化每个object的,它也可以给object的各个属性赋值,只要定义了一个class,系统就会默默生成一个和class同名的method(也就是constructor构造器).
如果你正在编写 Java 代码，那么你已经在使用构造器了，即使你可能不知道它。Java 中的所有class类都有一个构造器constructor，因为即使你没有创建构造器，Java 也会在编译代码时为你生成一个隐藏的构造器。所以其实我们之前已经用了很多次constructor.

举例,这是用户自建的testjan05.java文件

public class testjan05 {
    int x=8; // Create a class attribute
    String y="hello_world!";

    public static void main(String[] args) {
        int x=3;
        System.out.println(x);
    }
}

利用IDEA的反编译功能,找到系统生成的同名testjan05.class文件,这个文件内容是这样的:(看到系统默默加了一小段编码如下,这其实就是默默生成了同名的constructor)
public testjan05() { }

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

public class testjan05 {
    int x = 8;
    String y = "hello_world!";

//下面的这个部分就是系统默默实例化了一个对象
    public testjan05() {
    }

    public static void main(String[] args) {
        int x = 3;
        System.out.println(x);
    }
}

换言之：constructor构造器是在 Java 中创建新对象(object)时执行的操作。当 Java 应用程序创建一个class类的实例时，它就会制造一个同名的构造器。如果（该class类）存在用户自建的同名构造器，则 Java 在创建实例时将运行用户自建的构造器中的代码。

继续举例,如果程序员自建了class同名的constructor,那么程序员自建的constructor比系统默默生成的那个constructor优先级更高


public class testjan05 {
    String y="i_am_inside_the_class!";

    public testjan05(String m) {
//注意自建的constructor一定要和class同名
//可以看出这里面的元素y和class共用 不需要再二次定义y元素的type
        m="I'm inside the constructor";
        y=m;
    }
    public static void main(String[] args) {
	
  	//因为新建的public testjan05(String m)没有写public static所以必须新建一个对象才能使用   
        testjan05 newobj = new testjan05("im from the main method");
	
        System.out.println(newobj.y);
    }
}

// Outputs "I'm inside the constructor"

通过IDEA反编译回同名class文件,class文件的内容是这样的

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

public class testjan05 {
    String y = "i_am_inside_the_class!";

    public testjan05(String m) {
        m = "I'm inside the constructor";
        this.y = m;
    }

    public static void main(String[] args) {
        testjan05 newobj = new testjan05("im from the main method");
        System.out.println(newobj.y);
    }
}

总结:class中的constructor构造器也称构造方法是在进行创建对象时候必须会调用的。
构造器的两个特点：
1.必须和类名字相同
2. 必须没有返回类型，也不能写void