JAVA基础-方法(5)

- - - 1、方法介绍
    - <br />2、方法的重载（在同一个类中，方法名相同，列表参数不同（数量不同，类型不同，顺序））
    - 3、方法的重写（方法的覆盖-参数类别相同，返回值相同，存在继承关系）
    - 4、方法的调用
    - 5、方法的递归：
    - 6、构造方法
    - 7、方法的内存图分析

1、方法介绍

1、方法时定义在类体当中的
2、什么是方法：方法就是一个代码片段，，并且这个代码片段可以完成某个功能，并且可以重复使用
3、方法体中不能再定义一个方法

方法的的写法：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

:::tips
关于修饰符：
1、可选项，不是必须的
2、目前统一写成 public static
3、方法中带static 关键字的话，如何调用
类名.方法名(实际参数列表)
返回值类型：
1、一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要
返回最终结果的，执行结果肯能是一个存在的数据，而这个具体的数据就是返回值类型

2、java的返回值类型有哪些
java任意一种类型都可以，包括基本数据类型和所有的引用数据类型

3、形式参数列表：简称形参
形式参数列表是局部变量：int A ;等于
:::

:::tips
程序的入口：主方法

	public static void main(String[] args) {}<br />		<br />		形式参数列表： String[]是一种应用数据类型 args 是一个局部变量<br />		其本质和自己写的方法没有区别<br />		<br />		<br />接收方法的返回值:比如计算两个数的和，返回值类型为int，所以用int类型的数据接收<br />		int i = sum(1,2)

:::

:::info

方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
2. 方法定义的前后顺序无所谓。
3. 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
4. 如果方法有返回值，那么必须写上“return 返回值;”，不能没有。
5. return后面的返回值数据，必须和方法的返回值类型，对应起来。
6. 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
7. 对于void方法当中最后一行的return可以省略不写。
8. 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写
:::

2、方法的重载（在同一个类中，方法名相同，列表参数不同（数量不同，类型不同，顺序））

上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？
解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

:::info
功能相似的时候，方法名可以相同
在同一个类中
方法名相同
参数列表不同
数量不同
顺序不同
类型不同
:::

3、方法的重写（方法的覆盖-参数类别相同，返回值相同，存在继承关系）

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

:::info
在重写方法时，需要遵循以下的规则：
(一) 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。

(二) 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。

(三) Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。编写过Java程序的人就知道，父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。

(四) 由于父类的访问权限修饰符的限制一定要大于被子类重写方法的访问权限修饰符，而private权限最小。所以如果某一个方法在父类中的访问权限是private，那么就不能在子类中对其进行重写。如果重新定义，也只是定义了一个新的方法，不会达到重写的效果。

(五) 在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。同样的道理，如果子类中创建了一个成员变量，而该变量和父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此概念一般很少有人去研究它，因为意义不大。
:::

4、方法的调用

ava 支持两种调用方法的方式，根据方法是否返回值来选择。
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：
:::info
int larger = max(30, 40);
:::
如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：
:::info
System.out.println(“欢迎访问菜鸟教程！”);
:::

方法的三种调用格式。

单独调用：方法名称(参数);
打印调用：System.out.println(方法名称(参数));
赋值调用：数据类型变量名称 = 方法名称(参数);

5、方法的递归：

			 public static void main(String[] args) {
									m1(1);
													}
					public static void m1(int a){
								m1(1);
								}

6、构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
一旦你定义了自己的构造方法，默认构造方法就会失效。

// 一个简单的构造函数
class MyClass {
  int x;
 
  // 以下是构造函数
  MyClass(int i ) {
    x = i;
  }
}

你可以像下面这样调用构造方法来初始化一个对象：

public class ConsDemo {
  public static void main(String[] args) {
    MyClass t1 = new MyClass( 10 );
    MyClass t2 = new MyClass( 20 );
    System.out.println(t1.x + " " + t2.x);
  }
}

7、方法的内存图分析

方法一的内存图分析

public class Student {
    int age;
    String name;
    address add;
    int id;
}

public class address {

    String street;
    String city;
    int Zipcode;

}


=========================方法一：或者以下写法，结果都是一样的======================
public static void main(String[] args) {
        Student s = new Student();
        int stuage=s.age;
        s.add = new address();
        s.add.city="上海";
        System.out.println(s.add.city);
    }
// new address（是一个对象）


=========================方法二：或者以下写法，结果都是一样的======================
    //a是一个引用，也是一个局部变量
        public static void main(String[] args) {
        Student s = new Student();
        address a = new address();
        s.add= a;
        a.city="山海";
        System.out.println(s.add.city);
    }

方法二的内存图分析

jvm的介绍：

1、jvm（java虚拟机）主要包含三块内存空间，分别是：栈内存堆内存，方法去内存
2、堆内存和方法区内存个有一个，一个线程一个站内存
3、方法调用的时候，发方法所需额内存空间在栈内存中分配，成为压栈，方法取执行结束后，该方法所属的内存空间释放，称为弹栈
4、栈中主要存储的是方法体当中的局部变量
5、方法的代码片段以及整个类的代码片段都会被储蓄到方法去内存当中，在类加载的时候这些代码会被加载
6、在程序执行过程中使用new运算符创建java对象，储蓄在堆内存当中，对象内部有实力变量，所以实例变量储存在堆内存当中
7、变量分类：
局部变量【在方法体中声明】
成员变量【在方法体外申明】
* 实例变量【前面修饰没有static】
* 静态变量【前面修饰有static】

public static void main(String[] args) { Student s = new Student(); int stuage=s.age; address a = new address(); a=null; s.add= a; a.city=“山海”; System.out.println(s.add.city); }8、静态变量储蓄在方法区域内存当中
9、三块内存中变化最频繁的是栈内存，最优数据的是方法区域内存，垃圾回收期主要针对的是堆内存
10、垃圾回收期【自动垃圾回收机制，gc机制】什么时候考虑将某个java对象的内存回收
当堆内存的java对象成为垃圾数据的时候，会被垃圾回收器回收
什么时候堆内存的家吧对象会变成垃圾
没够更多的引用指向他的时候
这个对象无法被方位，应为方位对象只能通过引用的方式访问

空指针：

    public static void main(String[] args) {
        Student s = new Student();
        int stuage=s.age;
        address a = new address();
        a=null;
        s.add= a;
        a.city="山海";
        System.out.println(s.add.city);
    }