java

结构：

权限修饰符 [特征修饰符] 返回类型 方法名字(参数列表) [抛出异常]{

    方法内容。

}

方法代码存在硬盘中，会在方法区存一个映射。

Test t = new Test()；

参数t存在栈内存中，储存了实例的内存地址

实例存在堆内存中

实例的方法也存在堆内存中，执行时临时放在栈内存中执行

主方法main不属于任何class，而是属于虚拟机。（不需要调用）

测试：

import java.util.*;
public class Test{

    public int num = 1;

    public void changArray(int[] a){
        a[0] = 10;
    }

    public void changNum(int a){
        a = 10;
    }


    public static void main(String[] args){


        System.out.println("---class是引用数据类型，它的实例存在堆内存中，参数m1,m2在栈内存中存的是实例在堆内存的地址，m2 = m1赋给m2的是m1的地址，所以m1改变时m2也会改变---");
        Test m1 = new Test();
        m1.num = 1;
        Test m2 = new Test();
        m2 = m1;
        System.out.println(m1.num);
        m2.num = 2;
        System.out.println(m1.num);//m2修改后，m1也改变了

        System.out.println("---数组也是引用数据类型，变量存的也是地址---");
        int[] a1 = new int[]{1,2,3};
        System.out.println(a1[0]);
        m1.changArray(a1);
        System.out.println(a1[0]);//数组作为参数在方法中被操作后，方法执行完毕本身发生了变化

        int a2 = 1;
        System.out.println(a2);
        m1.changNum(a2);
        System.out.println(a2);//数字作为参数在方法中被操作后，方法执行完毕本身不变化

} }

方法重载：

一个类中的一组方法，有相同的名字，不同的参数。

便于记忆和使用

public class Overload {

    public void show(String s){
        System.out.println("传入了一个String：" + s);
    }

    public void show(int i){
        System.out.println("传入了一个int：" + i);
    }

    public void show(int... iArray){
        int n = iArray.length;
        System.out.println("动态传入了" + n + "个int");
        for(int e:iArray){
            System.out.print(e + "  ");
        }
        System.out.println();
    }

    public void show(int i, String... sArray){

        System.out.println("传入了一个int：" + i);

        int n = sArray.length;
        System.out.println("动态传入了" + n + "个String");
        for(String e:sArray){
            System.out.print(e + "  ");
        }
        System.out.println();
    }

    public void show(String s, String... sArray){

        System.out.println("传入了一个String：" + s);

        int n = sArray.length;
        System.out.println("动态传入了" + n + "个String");
        for(String e:sArray){
            System.out.print(e + "  ");
        }
        System.out.println();
    }


    public static void main(String[] args){
        Overload o = new Overload();

        //重载方法会根据方法名和参数类型定位执行哪一个
        o.show("123");
        o.show(123);
        System.out.println("--------------------------------");

        //当没有参数类型一致的时候，会找一个参数类型可以自动转换的：char-int，byte-int等
        byte b = 123;
        o.show(b);
        char c = 'a';
        o.show(c);
        System.out.println("--------------------------------");

        //jdk1.5后加入了动态参数列表 本质是把不确定个数的参数变为数组,所以有index和length等，可以不穿参数
        o.show(1,2,3,45,678,'a');
        System.out.println("--------------------------------");

        // 动态参数只能存在一个，且放在末尾。
        //不能同时定义public void show(String s1, String... s) 和 public void show(String... s) 它们本质一样
        String[] s = {"a", "ab", "abc", "d"};
        o.show("aaa", s);
        o.show(123, "bbb", "ccc");
    }
}

构造方法：

权限修饰 返回值（省略） 和类名一致的方法名， 构造方法在new的时候执行，子类new时会运行父类的构造方法

public class Person {

    //属性
    public String name;
    public int age;

    //构造方法
    public Person(){
        System.out.println("Person的构造方法");
    }

    //程序块，只有{}, 调用构造方法之前，系统调用
    {
        System.out.println("我要创建新实例了！");
    }


    public Person(String name){
        System.out.println("Person的带参数的构造方法1");
        this.name = name;//为了区分参数name和类的属性name，用this区分，this.name表示class的属性name
    }

    public Person(String name, int age){
        this(name); //构造方法，必须写在其他构造方法的第一行，可用来补充
        System.out.println("Person的带参数的构造方法2");
        this.age = age;//为了区分参数name和类的属性name，用this区分，this.name表示class的属性name
    }



    //方法
    public void show(){
        System.out.println("name = " + this.name);
        System.out.println("age = " + this.age);
    }

    public static void main(String[] args){
        Person p1 = new Person();
        p1.name = "aaa";
        p1.show();

        Person p2 = new Person("bbb");
        p2.show();

        Person p3 = new Person("ccc", 14);
        p3.show();
    }
}