第二周Java学习笔记（头发果然稀疏了许多）第十四章方法-第十六章对象

本文链接：https://blog.csdn.net/qq_19627109/article/details/109586664

第十四章：方法

14.1 方法的复习

基本定义格式：

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

调用格式：

方法名称();

注意事项：

1.方法定义的先后顺序无所谓

2.方法定义必须是挨着的，不能在一个方法内部定义另外一个方法

3.方法定义之后，自己不会执行，如果要执行，一定要进行方法的调用

14.2 方法的定义

**方法：**其实就是若干语句的功能集合

**参数：**进入方法的数据（原料）

**返回值：**从方法中出来的数据（产出物）

定义方法的完整格式：

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

**修饰符：**现阶段的固定写法：public static

**返回值类型：**也就是方法最终产生的数据结果是什么类型

**方法名称：**方法的名字，规则和变量一样，小驼峰

**参数类型：**进入方法的数据是什么类型

**参数名称：**进入方法的数据对应的变量名称

**ps：**参数如果有多个，使用逗号进行分隔

**方法体：**方法需要做的事情，若干行代码

**return：**两个作用，A、停止当前方法 B、将后面的返回值还给调用处

**返回值：**方法执行后最终产生的数据结果

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应

public class Demosum
{
	public static void main(String[]args)
	{
		int a=1,b=2;
		sum(a,b);
	}
	public static int sum(int a,int b)
	{
		return a+b;
	}
}

14.3 方法的三种调用格式

1.单独调用

格式:

方法名称(参数);

2.打印调用

格式：

System.out.println(方法名称(参数));

3.赋值调用

格式：

数据类型  变量名称=方法名称（参数）;

注：此前学习的方法，返回值类型固定写为void,这种方法只能单独调用，不能进行打印调用或者赋值调用

14.4 方法执行的流程

1、根据调用，找到方法

2、参数传递

3、执行方法体

4、带着返回值回到方法的调用处[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HtxB1xCT-1604927997474)(D:\学习\Java\图片\7.png)]

14.5 对比有参数和无参数

**有参数：**小括号中有内容，即当一个方法需要一些数据条件，才能完成任务的时候

**无参数：**小括号中留空，即一个方法不需要任何数据条件，自己就能独立完成任务

14.5 对比有返回值和无返回值

**有返回值：**方法执行完将返回值交还给调用处

**无返回值：**方法执行完直接结束

注意：

1、对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用

2、对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用

14.6 方法的注意事项

1、方法应该定义在类当中，但是不能在方法中再定义方法，不能嵌套

2、方法定义的前后顺序无所谓

3、方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用

4、如果方法有返回值，必须写上"return 返回值;"，不能没有

5、return后面的返回值数据，必须和方法的返回值类型对应起来

6、对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。此时return的作用是结束方法

7、对于一个void没有返回值的方法，方法中最后一行的return可以省略不写

8、一个方法中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写

14.7 方法重载（Overload）

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦

**方法重载（Overload）：**多个方法的名称一样，但是参数列表不同

**好处：**只要记住唯一一个方法名称，就可以实现类似的多个功能

方法重载与下列因素相关：

1、参数个数不同

2、参数类型不同

3、参数的多类型顺序不同（类型不同的数据顺序颠倒）

方法重载与下列因素无关：

1、与参数的名称无关

2、与方法的返回值类型无关

判断哪些方法是重载关系：

1 public static void open();					//正确
2 public static void open(int a);				//正确
3 static void open(int a,int b);				//代码错误，和第八行冲突
4 public static void open(double a,int b);		//正确
5 public static void open(int a,double b);		//代码错误，和第6行冲突
6 public void open(int i,double d);				//代码错误，和第5行冲突
7 public static void OPEN();					//代码正确不会报错，但并不是有效重载
8 public static void open(int i,int j);			//代码错误，和第三行冲突

在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式

第十五章：数组

15.1 数组的概念

**数组：**是一种容器，可以存放多个数据值。

特点：

1、数组是一种引用数据类型

2、数组当中的多个数据，他们的类型必须统一

3、数组的长度在程序运行期间不可改变

15.2 数组的定义

**数组的初始化：**在内容中创建一个数组，并且向其中赋予一些默认值

两种基本的初始化形式：

1、**动态初始化（指定长度）：**在创建数组时，直接指定数组中数据元素的个数

2、**静态初始化（指定内容）：**在创建数组时，不指定数组中数据元素的个数，而是直接指定具体的数据内容

动态初始化数组的格式：

数据类型[] 数据名称=new 数据类型[数组长度];

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：

如果是整数类型，默认为0;

如果是浮点类型，默认为0.0;

如果是字符类型，默认为’/u0000’; 十六进制的0

如果是布尔类型，默认为false;

如果是引用类型，默认为null;

静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为大括号中的具体数值

解析含义：

左侧数据类型，也就是数组中保存的数据，全部都是统一的什么类型

左侧的中括号，代表我是一个数组

左侧的数组名称，给数字取一个名字

右侧的new，代表创建数组的动作

右侧的数据类型必须和左侧的数据类型保持一致

右侧中括号的长度，也就是数组当中，到底可以保存几个数据，是一个int数字

int[] arrayA=new int[300];//创建一个数组，可以存放300个int数据
double[] arrayB=new double[10];//创建一个数组，可以存放10个double数据
String[] arrayC=new String[5];//创建一个数组，可以存放5个String数据

静态初始化数组的格式：

**标准格式：**数据类型[] 数据名称=new 数据类型[] {元素1,元素2,…};

//直接创建一个数组，里面装的是int数字，5、15、25
int[] arrayA=new int[]{5,15,25};
//直接创建一个数组，里面装的是字符串，"Hello","World","Java"
String[] arrayB=new System[]{"Hello","World","Java"};

**省略格式：**数据类型[] 数据名称={元素1,元素2,…};

int[] arrayA={10,20,30};
```java

**注意：**

**1、静态初始化没有直接指定长度，但是仍然会自动推算得到长度**

**2、静态初始化标准格式可以拆分成为两个步骤:**

```java
int[] arrayB;
arrayB=new int[]{10,20,30};

3、动态初始化标准格式也可以拆分成为两个步骤:

int[] arrayC;
arrayC=new int[10];

4、动态初始化一旦使用省略格式，就不能拆分成为两个步骤了

使用建议：

如果不确定数组中的具体内容，用动态初始化，否则，已经确定了具体的内容，用静态初始化

15.3 访问数组元素进行获取

访问数组元素的格式：

数组名称[索引值]

**索引值：**就是一个int数字，代表数组当中元素的编号

注：索引值从0开始，一直到“数组的长度-1”为止

如果直接输出数组名称，则得到的是十六进制的对应数组的内存地址哈希值

15.4 访问数组元素进行赋值

格式：

//将数据123赋值给数组array中的1号元素
array[1]=123;

15.5 Java中的内存划分

Java的内存需要划分成为5个部分：

1、**栈（stack）：**存放的都是方法中的局部变量。方法的运行一定要在栈当中

局部变量：方法的参数，或者是方法{}内部的变量

作用域：一旦超出作用域，立即从栈内存中消失

2、堆(Heap)：凡是new出来的东西，都在堆当中

堆内存里面的东西都有一个地址值：16进制

堆内存里面的数据都有默认值，规则为：

整数	默认为0
浮点数	0.0
字符	‘\u0000’
引用类型	null
布尔	false

3、**方法区（Mqthod Area）：**存储.class相关信息，包含方法的信息

4、本地方法栈（Native Method Stack）:与操作系统相关

5、寄存器（pc Register）:与cpu相关

15.6 一个数组的内存图

在这里插入图片描述

15.7 两个数组的内存图

在这里插入图片描述

两个引用指向同一个数组的的地址：

int[]arrayA={1,2,3};
int[]arrayB=arrayA;		//将arrayA数组的地址值赋给arrarB数组

在这里插入图片描述

15.8 常见问题

常见问题1：数组索引越界异常（ArrayIndexOutOfBoundsException）

数组的索引编号从0开始，一直到“数组的长度-1”为止

原因：索引编号写错了

解决：修改成为存在的正确索引编号

常见问题2：空指针异常（NullPorintException）

所有的引用类型变量，都可以赋值为一个null值，但是代表其中什么都没有

数组必须进行new初始化才能使用其中的元素，如果只是赋了一个null，没有进行new创建，那么将会发生空指针异常

原因：忘了new

解决：补上new

15.9 获取数组的长度

**格式：**数组名称.Length

这将会得到一个int数字，代表数组的长度

注：数组一旦创建，程序运行期间，长度不可改变

15.10 数组的遍历输出

**遍历数组：**对数组中每一个元素进行逐一、挨个处理。默认的处理方式就是打印输出

15.11 数组元素反转

1、数组元素反转，其实就是对称位置的元素交换

2、表示对称位置需要两个索引

3、用第三个变量倒手

4、当min<max时应该交换在这里插入图片描述

数组可以作为方法的参数，当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值

15.12 数组作为方法的返回值

一个方法可以有0、1、多个参数，但是只能有0或1个返回值，不能有多个返回值

如果希望一个方法中产生多个结果数据进行返回，应该使用一个数组作为返回值类型即可

public stasic int[] calculate(int a,int b,int c){
int sum=a+b+c;
int avg=sum/3;
int[] array=new int[3];
array[0]=sum;
array[1]=avg;
return array;
}

1、任何数据类型都能作为方法的参数类型，或者返回值类型

2、数组作为方法的参数，传递进去的其实是数组的地址值

3、数组作为方法的返回值，返回的其实也是数组的地址值

第十六章：面向对象

16.1 概述

**面向过程：**当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节

**面向对象：**当需要实现一个功能的时候，不关心具体步骤，而是找一个已经具有该功能的人来帮我做事

面向过程：强调步骤面向对象：强调对象

**特点：**面向对象思想是一种更符合我们思考习惯的思想，他可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征——封装、继承、多态

16.2 类和对象

什么是类

类：一组相关属性和行为的集合，可以看成一类事物的模板，使用事物的属性特征和行为特征来描述该事物
**属性：**该事物的状态信息
**行为：**该事物能做什么

什么是对象

**对象：**是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为

类与对象的关系：

类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体

16.3 类的定义

属性和行为对应到Java中分别为：成员变量、成员方法

成员变量（属性）：

String name;//姓名
int age;//年龄

成员方法（行为）：必须删去static

	public void eat(){}
	public void sleep(){}
	public void study(){}

具体：

public class Student{
    //成员变量
    String name;
    int age;
    //成员方法
    public void eat(){
        System.ot.println("吃饭！");
    }
    public void sleep(){
         System.ot.println("睡觉！");
    }
    public void study(){
        System.ot.println("学习！");
    }
}

注意：

1、成员变量是直接定义在类中的，在方法外面

2、成员方法不要写static关键字

16.4 对象的创建及其使用

通常情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用

如何创造一个对象：

**1、导包：**指出需要使用的类在什么位置

import	包名称.类名称;
import	cn.itcast.day06.demo01.Student
对于和当前类属于同一个包的情况，可以省略导包语句不写

2、创建：

类名称 对象名=new 类名称();
Student stu=new Student();

**3、使用：**有两种情况

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名(参数)

想用谁，就用对象名点谁

注意：

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样

16.5 对象的内存图

1、一个对象的内存图

在这里插入图片描述

2、两个对象使用同一个方法的内存

3、使用对象类型作为方法的参数

注意：当一个对象/数组/类作为参数，传递到方法中时，实际上传递过去的是对他们的地址值。
在这里插入图片描述

16.6 使用对象类型作为方法的返回值

public class Sreturn {
    public static void main(String[] args) {
        Student two=getfirst();
        System.out.println(two.name);
        System.out.println(two.age);
        System.out.println(two.sex);
    }
    public static Student getfirst(){
        Student first=new Student();
        first.score[0]=1;
        first.score[1]=2;
        first.score[2]=3;
        first.name="二狗子";
        first.age=18;
        return first;
    }
}
//二狗子
//18
//null

当使用一个对象类型作为方法的返回值时，返回值其实就是对象的地址值

内存图：
在这里插入图片描述

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

1、定义的位置不一样【重】

局部变量：在方法内部

成员变量：在方法的外部，直接写在类中

2、作用范围不一样【重】

局部变量：只有在方法中才可以使用，出了方法就不能再用

成员变量：整个类都可以用

3、默认值不一样【重】

局部变量：没有默认值，如果想要使用，必须手动进行赋值

成员变量：如果没有赋值，会有默认值，规则和数组一样

4、内存的位置不一样（了解）

局部变量：位于栈内存

成员变量：位于堆内存

5、生命周期不一样（了解）

局部变量：随着方法进栈而诞生，随着方法出栈而消失

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

16.8 面向对象语言的封装性

封装性在Java中的体现：

1、方法就是一种封装

2、关键字private也是一种封装

封装：将一些细节信息隐藏起来，对于外界不可见

16.9 关键字private（私有化）

private作用：将需要被保护的成员变量进行修饰

一旦使用了private进行修饰，那么本类当中仍然可以随意访问，但是，超出了本范围之外就不能再直接访问了,但是可以间接访问

**格式：**在需要被保护的成员变量的类型前+private

间接访问private成员变量就是定义一对getter/setter方法

public int getAge2(){
     return age2;
}
public void setAge2(int num) {
    if(num<100&&num>=9)
    	 age2 = num;
    else
        System.out.println("数据不合理！");
}
特殊！！！布尔类型：//
public void setMale(boolean b){
    male=b;
}
public boolean isMale(){
    return male;
}

注意：

1、必须叫setXxx或者getXxx命名

2、对于getter来说，不能有参数，返回值类型和成员变量对应

3、对于setter来说，不能有返回值，参数类型和成员变量对应

4、对于boolean类型，Getter方法一定要写成isXxx的形式，而setXxx规则不变

16.10 关键字this

当方法的局部变量和类的成员变量重名时，根据“就近原则”，优先使用局部变量

如果需要访问本类当中的成员变量，需要使用格式：

this.成员变量名

通过谁调用的方法，谁就是this

16.11 构造方法

**构造方法：**专门用来创建对象的方法，当我们通过关键字new来创建对象是，其实就是在调用构造方法

格式：

public 类名称(参数类型 参数名称){
    方法体
}

注意：

1、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

2、构造方法不要写返回值类型，连void也不写

3、构造方法不能return一个具体的返回值

4、如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做

5、一旦编写了至少一个构造方法，那么编译器将不再赠送

6、构造方法也可以进行重载

16.12 定义一个标准的类

一个标准的类通常拥有以下四个组成部分：

1、所有的成员变量都要使用private关键字修饰

2、为每一个成员变量编写一对Getter/Setter方法

3、编写一个无参数的构造方法

4、编写一个全参数的构造方法

这样标准的类也叫做Java Bean

第二周Java学习笔记（头发果然稀疏了许多） 第十四章方法-第十六章对象

第十四章：方法

14.1 方法的复习

14.2 方法的定义

14.3 方法的三种调用格式

1.单独调用

2.打印调用

3.赋值调用

14.4 方法执行的流程

14.5 对比有参数和无参数

14.5 对比有返回值和无返回值

14.6 方法的注意事项

14.7 方法重载（Overload）

第十五章：数组

15.1 数组的概念

15.2 数组的定义

动态初始化数组的格式：

静态初始化数组的格式：

15.3 访问数组元素进行获取

15.4 访问数组元素进行赋值

15.5 Java中的内存划分

15.6 一个数组的内存图

15.7 两个数组的内存图

15.8 常见问题

常见问题1：数组索引越界异常（ArrayIndexOutOfBoundsException）

常见问题2：空指针异常（NullPorintException）

15.9 获取数组的长度

15.10 数组的遍历输出

15.11 数组元素反转

15.12 数组作为方法的返回值

第十六章：面向对象

16.1 概述

16.2 类和对象

什么是类

什么是对象

类与对象的关系：

16.3 类的定义

16.4 对象的创建及其使用

16.5 对象的内存图

1、一个对象的内存图

2、两个对象使用同一个方法的内存

3、使用对象类型作为方法的参数

16.6 使用对象类型作为方法的返回值

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

1、定义的位置不一样【重】

2、作用范围不一样【重】

3、默认值不一样【重】

16.8 面向对象语言的封装性

封装性在Java中的体现：

封装：将一些细节信息隐藏起来，对于外界不可见

16.9 关键字private（私有化）

16.10 关键字this

16.11 构造方法

16.12 定义一个标准的类

第二周Java学习笔记（头发果然稀疏了许多）第十四章方法-第十六章对象