java SE基础

本博客的全部文章（除文章标题或文中有特别说明的）均为本人原创，本人拥有其版权。所有原创文章的整体设计，文章撰写均为自己完成。另外文中如有引用别人文章的内容、部分句子以后将尽量注明出处。如有遗漏之处，欢迎之处，本人将于24小时内做出回复并进行确认，维护版权所有者相关利益。

博客地址：https://blog.csdn.net/flyingwzb/article/details/85002850

1. 方法

1.1 定义方法的完整格式

• 定义方法的完整格式:

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

  1. 修饰符：现阶段的固定写法，public static
  2. 返回值类型：也就是方法最终产生的数据结果是什么类型
  3. 方法名称：方法的名字，规则和变量一样，小驼峰
  4. 参数类型：进入方法的数据是什么类型
  5. 参数名称：进入方法的数据对应的变量名称
     
     PS：参数如果有多个，使用逗号进行分隔
  6. 方法体：方法需要做的事情，若干行代码
  7. return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
  8. 返回值：也就是方法执行后最终产生的数据结果
     
     注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。

• 定义一个两个int数字相加的方法。三要素：

  • 返回值类型：int
  • 方法名称：sum
  • 参数列表：int a, int b

• 方法的三种调用格式。

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

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

1.2 有无参数的方法

• 有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
  
  例如两个数字相加，必须知道两个数字是各自多少，才能相加。
• 无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
  
  例如定义一个方法，打印固定10次HelloWorld。

1.3 使用方法注意事项

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

1.4 方法的重载

• 对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。
• 方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
  • 好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

1. 方法重载与下列因素相关：
   1. 参数个数不同
   2. 参数类型不同
   3. 参数的多类型顺序不同
2. 方法重载与下列因素无关：
   1. 与参数的名称无关
   2. 与方法的返回值类型无关

2. 数组

2.1 数组的概念与特点

• 数组的概念：是一种容器，可以同时存放多个数据值。
• 数组的特点:
  • 数组是一种引用数据类型
  • 数组当中的多个数据，类型必须统一
  • 数组的长度在程序运行期间不可改变
• 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
  • 两种常见的初始化方式：
  1. 动态初始化（指定长度）
  2. 静态初始化（指定内容）
• 动态初始化数组的格式：
  数据类型[] 数组名称 = new 数据类型[数组长度];
  • 解析含义：
  1. 左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
  2. 左侧的中括号：代表我是一个数组
  3. 左侧数组名称：给数组取一个名字
  4. 右侧的new：代表创建数组的动作
  5. 右侧数据类型：必须和左边的数据类型保持一致
  6. 右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

2.2 动态初始化与静态初始化

• 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
• 静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
• 静态初始化基本格式：
  • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
• 注意事项：
  • 虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

2.3 静态初始化格式

• 使用静态初始化数组的时候，格式还可以省略一下。
• 标准格式：
  • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
• 省略格式：
  • 数据类型[] 数组名称 = { 元素1, 元素2, … };
• 注意事项：
  1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
  2. 静态初始化标准格式可以拆分成为两个步骤。
  3. 动态初始化也可以拆分成为两个步骤。
  4. 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。
• 使用建议：
  • 如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

2.4 数组索引

• 数组的索引编号从0开始，一直到“数组的长度-1”为止。
• 如果访问数组元素的时候，索引编号并不存在，那么将会发生
  数组索引越界异常
  ArrayIndexOutOfBoundsException
• 原因：索引编号写错了。
  解决：修改成为存在的正确索引编号。

3. 面向对象

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

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

3.1 new对象

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

1. 导包：也就是指出需要使用的类，在什么位置。
   
   import 包名称.类名称;
   
   import cn.itcast.day06.demo01.Student;
   
   对于和当前类属于同一个包的情况，可以省略导包语句不写。
2. 创建，格式：
   
   类名称 对象名 = new 类名称();
   
   Student stu = new Student();
   
3. 使用，分为两种情况：
   
   使用成员变量：对象名.成员变量名
   
   使用成员方法：对象名.成员方法名(参数)
   
   （也就是，想用谁，就用对象名点儿谁。）
   

• 注意事项：
  • 如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

3.2 局部变量和成员变量

1. 定义的位置不一样【重点】
   
   局部变量：在方法的内部
   
   成员变量：在方法的外部，直接写在类当中
   

2. 作用范围不一样【重点】
   
   局部变量：只有方法当中才可以使用，出了方法就不能再用
   
   成员变量：整个类全都可以通用。
   

3. 默认值不一样【重点】
   
   局部变量：没有默认值，如果要想使用，必须手动进行赋值
   
   成员变量：如果没有赋值，会有默认值，规则和数组一样
   

4. 内存的位置不一样（了解）
   
   局部变量：位于栈内存
   
   成员变量：位于堆内存
   

5. 生命周期不一样（了解）
   
   局部变量：随着方法进栈而诞生，随着方法出栈而消失
   
   成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
   

3.3 面向对象三大特征

• 面向对象三大特征：封装、继承、多态
• 封装性在Java当中的体现：
  1. 方法就是一种封装
  2. 关键字private也是一种封装
• 封装就是将一些细节信息隐藏起来，对于外界不可见。

3.4 封装

• 问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。
• 解决方案：用private关键字将需要保护的成员变量进行修饰。
• 一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
  但是！超出了本类范围之外就不能再直接访问了。
• 间接访问private成员变量，就是定义一对儿Getter/Setter方法
• 必须叫setXxx或者是getXxx命名规则。
  • 对于Getter来说，不能有参数，返回值类型和成员变量对应；
  • 对于Setter来说，不能有返回值，参数类型和成员变量对应。

3.5 构造方法

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

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

• 注意事项：
  1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
  2. 构造方法不要写返回值类型，连void都不写
  3. 构造方法不能return一个具体的返回值
  4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
     public Student() {}
  5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
  6. 构造方法也是可以进行重载的。
     重载：方法名称相同，参数列表不同。

3.6 Java Bean

• 一个标准的类通常要拥有下面四个组成部分：
  1. 所有的成员变量都要使用private关键字修饰
  2. 为每一个成员变量编写一对儿Getter/Setter方法
  3. 编写一个无参数的构造方法
  4. 编写一个全参数的构造方法
• 这样标准的类也叫做Java Bean

4. Scanner类

• Scanner类的功能：可以实现键盘输入数据，到程序当中。
• 引用类型的一般使用步骤：
  1. 导包
     
     import 包路径.类名称;
     
     如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
     
     只有java.lang包下的内容不需要导包，其他的包都需要import语句。
     
  2. 创建
     
     类名称 对象名 = new 类名称();
  3. 使用
     
     对象名.成员方法名()
• 获取键盘输入的一个int数字：int num = sc.nextInt();
• 获取键盘输入的一个字符串：String str = sc.next();

4.1 new对象格式

• 创建对象的标准格式：
  • 类名称 对象名 = new 类名称();
• 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
  • new 类名称();
• 注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
• 使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

5. Random类

• Random类用来生成随机数字。使用起来也是三个步骤：

1. 导包
   
   import java.util.Random;
2. 创建
   
   Random r = new Random(); // 小括号当中留空即可
3. 使用
   
   获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()
   
   获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
   
   实际上代表的含义是：[0,3)，也就是0~2

6. 数组与集合的区别

• 数组的长度不可以发生改变。
• 但是ArrayList集合的长度是可以随意变化的。
• 对于ArrayList来说，有一个尖括号代表泛型。
  • 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
  • 注意：泛型只能是引用类型，不能是基本类型。
• 注意事项：
  • 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
  • 如果内容是空，得到的是空的中括号：[]

7. 包装类

• 如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。

  基本类型	包装类（引用类型，包装类都位于java.lang包下）
  byte	Byte
  short	Short
  int	Integer 【特殊】
  long	Long
  float	Float
  double	Double
  char	Character 【特殊】
  boolean	Boolean

  继续阅读与本文标签相同的文章

  无标签