一、方法

内容

1. 方法的概念
2. 方法的定义和调用
3. 带参数方法定义和调用
4. 带返回值方法的定义和调用
5. 方法的注意事项
6. 方法的通用格式
7. 方法重载
8. 方法的参数传递

（一）方法的概念

1. 概念

	方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

2. 注意

1. 方法必须先创建才可以使用，该过程成为方法定义
2. 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

（二）方法的定义和调用

1. 定义格式

public static void 方法名 (   ) {
	// 方法体;
}

2. 调用格式

方法名();

3. 注意

方法必须先定义，后调用，否则程序将报错

4. 方法调用过程图解

总结:
	每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。

（三）带参数方法定义和调用

1. 参数

	参数：由数据类型和变量名组成 - 数据类型 变量名

2. 定义格式1

public static void 方法名 (参数1) {
	方法体;
}

3. 定义格式2

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

4. 注意

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

方法定义时，多个参数之间使用逗号( ，)分隔

5. 调用格式

方法名(参数)；

方法名(参数1,参数2);

6. 注意

方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

7. 形参和实参

1. 形参：方法定义中的参数
	等同于变量定义格式，例如：int number
2. 实参：方法调用中的参数
	等同于使用变量或常量，例如：10 number

（四）带返回值方法的定义和调用

1. 定义格式

public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

2. 注意

方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

3. 调用格式

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

4. 注意

方法的返回值通常会使用变量接收，否则该返回值将无意义

（五）方法的注意事项

1. 方法不能嵌套定义

public class MethodDemo {
    public static void main(String[] args) {

    }

    public static void methodOne() {
		public static void methodTwo() {
       		// 这里会引发编译错误!!!
    	}
    }
}

2. void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

public class MethodDemo {
    public static void main(String[] args) {

    }
    public static void methodTwo() {
        //return 100; 编译错误，因为没有具体返回值类型
        return;	
        //System.out.println(100); return语句后面不能跟数据或代码
    }
}

（六）方法的通用格式

1. 通用格式

public static 返回值类型 方法名(参数) {
   方法体; 
   return 数据 ;
}

2. 解释

1. public static	修饰符，目前先记住这个格式
	1). 返回值类型  方法操作完毕之后返回的数据的数据类型
	如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
    2). 方法名  调用方法时候使用的标识
	3). 参数  由数据类型和变量名组成，多个参数之间用逗号隔开
	4). 方法体  完成功能的代码块
	5). return  如果方法操作完毕，有数据返回，用于把数据返回给调用者

2. 定义方法时，要做到两个明确
	1). 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
	2).明确参数：主要是明确参数的类型和数量

3. 调用方法时的注意：
	1). void类型的方法，直接调用即可
	2). 非void类型的方法，推荐用变量接收调用

（七）方法重载

1. 方法重载的概念

1. 方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
	1). 多个方法在同一个类中
	2). 多个方法具有相同的方法名
	3). 多个方法的参数不相同，类型不同或者数量不同

2. 注意：
	1). 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
	2). 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

2. 正确范例

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}

public class MethodDemo {
	public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}

3. 错误范例

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { 	/*错误原因：重载与返回值无关*/
    	//方法体
    }
}

public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
        //方法体
    }
}

（八）方法的参数传递

1. 方法参数传递基本数据类型

1. 测试代码

public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        change(number);
        System.out.println("调用change方法后：" + number);
    }

    public static void change(int number) {
        number = 200;
    }
}

2. 结论

基本数据类型的参数，形式参数的改变，不影响实际参数 

3. 结论依据

每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

2. 方法参数传递引用数据类型

1. 测试代码

public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

2. 结论

对于引用类型的参数，形式参数的改变，影响实际参数的值 

3. 结论依据

引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果 

二、类和对象

内容

1. 类和对象
2. 对象内存图
3. 成员变量和局部变量

（一）类和对象

1. 类和对象的理解

* 对象
    客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。

* 类
  * 类的理解
    * 类是对现实生活中一类具有共同属性和行为的事物的抽象
    * 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
    * 简单理解：类就是对现实事物的一种描述

  * 类的组成
    * 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
    * 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

* 类和对象的关系
  * 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
  * 对象：是能够看得到摸的着的真实存在的实体
  * 简单理解：类是对事物的一种描述，对象则为具体存在的事物

2. 类的定义

类的组成是由属性和行为两部分组成
1. 属性：在类中通过成员变量来体现（类中方法外的变量）
2. 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：
1. 定义类
2. 编写类的成员变量
3. 编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}

/*
    手机类：
        类名：
        手机(Phone)

        成员变量：
        品牌(brand)
        价格(price)

        成员方法：
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

3. 对象的使用

* 创建对象的格式：
  * 类名 对象名 = new 类名();
* 调用成员的格式：
  * 对象名.成员变量
  * 对象名.成员方法();

/*
    创建对象
        格式：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

（二）对象内存图

1. 单个对象内存图

1. 成员变量使用过程

2. 成员方法调用过程

2. 多个对象内存图

1. 成员变量使用过程

2. 成员方法调用过程

3. 总结

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

3. 多个对象指向相同内存图

总结

当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）

只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

（三）成员变量和局部变量

成员变量和局部变量的区别

* 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
* 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
* 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
* 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

三、面向对象的三大特性（重点）

内容

1. 封装
2. 继承
3. 多态

（一）封装

内容

1. 封装思想
2. private关键字
3. this关键字、this内存原理
4. 构造方法
5. 标准类制作

1. 封装思想

1. 封装概述

是面向对象三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

2. 封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxx()/setXxx()方法

3. 封装好处

通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

2. private关键字

1. private概述

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

* 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
  * 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
  * 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

2. 示例代码

/*
    学生类
 */
class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());

    }
}

3. this关键字

1. this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

* 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
* 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

2. 示例代码

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

3. this内存原理

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

4. 示例代码

public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        Student s2 = new Student();
        s2.setName("张曼玉");
    }
}

5. this内存原理图解

4. 构造方法

1. 构造方法概述

构造、创造对象的时候，所调用的方法

2. 作用

作用：创建对象   Student stu = new Student();

3. 格式

public class 类名{
	修饰符 类名( 参数 ) {
	
	}
}

4. 执行时机

1. 创建对象的时候调用，每创建一次对象，就会执行一次构造方法
2. 不能手动调用构造方法

5. 功能

功能：主要是完成对象数据的初始化

6. 注意事项

1. 构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

2. 构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

3. 推荐的使用方式

无论是否使用，都手动书写无参数构造方法和带参构造方法

4. 重要功能！

可以使用带参构造，为成员变量进行初始化

7. 示例代码

/*
    学生类
 */
class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

5. 标准类制作

1. 成员变量
	使用 private 修饰
2. 构造方法
	提供一个无参构造方法
	提供一个带多个参数的构造方法
3. 成员方法
	提供每一个成员变量对应的setXxx()/getXxx()
	提供一个显示对象信息的show()
4. 创建对象并为其成员变量赋值的两种方式
	无参构造方法创建对象后使用setXxx()赋值
	使用带参构造方法直接创建带有属性的对象

（二）继承

内容

1. 继承的概念
2. 继承的好处和弊端
3. 继承中的成员访问特点
4. super关键字
5. 方法重写
6. Java中继承的注意事项
7. 修饰符

1. 继承的概念

1. 继承的概念

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

2. 实现继承的格式

继承通过extends实现

格式：class 子类 extends 父类 { } 

3. 继承带来的好处

继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

4. 示例代码

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

2. 继承的好处和弊端

1. 继承好处
    1). 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
    2). 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
    
2. 继承弊端
	继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
    
3. 继承的应用场景：
	使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
		is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

3. 继承中的成员访问特点

变量

构造方法

成员方法

1). 继承中变量的访问特定

在子类方法中访问一个变量，采用的是就近原则。
1. 子类局部范围找
2. 子类成员范围找
3. 父类成员范围找
4. 如果都没有就报错(不考虑父亲的父亲…)

class Fu {
    int num = 10;
}
class Zi {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();	// 输出show方法中的局部变量30
    }
}

2). 继承中构造方法的访问特定

3). 继承中成员方法的访问特定

4. super关键字

1. this & super

* this：代表本类对象的引用
* super：代表父类存储空间的标识(可以理解为父类对象引用)

本栏目推荐文章
• 【Shell基础】Bash基础与Linux三剑客
• 跟着阿灵学前端(1)——HTML 基础
• 跟着阿灵学前端(2)——CSS 基础
• OSPF理论基础
• （坚持每天写算法）基础算法复习与学习part1基础算法1-7——高精度减法（处理t=1和t>1代码的写法，t为操作次数）
• 9-函数基础
• 春眠不觉晓，Java数据类型知多少？基础牢不牢看完本文就有数了
• Servlet基础开发
• Linux基础命令 [补档-2023-06-28]
• 学习如何使用 Python 连接 MongoDB: PyMongo 安装和基础操作教程