Java第一篇基础知识复习

已于 2023-03-29 01:25:38 修改
阅读量209 收藏
点赞数
分类专栏： java 文章标签： java jvm servlet
于 2023-03-28 21:42:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_76549100/article/details/129801531
版权

2.1.java的基本语法

Java中的程序代码都必须放在一个类中，类需要使用class关键字定义

1.Java中的程序代码可分为结构定义语句和功能执行语句，其中,结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句的最后都必须用分号（；）结束。

System.out.println("这是第一个Java程序！");

2.Java语言严格区分大小写。例如，定义一个类时，computer和computer是两个完全不同的符号

3.虽然Java没有严格要求，用什么样的格式来编排程序代码，但是出于可读性的考虑，应该让自己编写的程序代码，整齐美观，层次清晰

4. Java程序中一句连续的字符串不能分开在两行中书写。
     如果为了便于阅读，想将一个太长的字符串分在两行中书写，可以先将这个字符串分成两个字符串，然后用加号将这两个字符串连起来，在加号处断行。

Java中的注释

在编写程序时为了使代码与阅读，通常会在实现功能的同时为代码写一些注释。注释是对程序的某个功能或某行代码的解释，说明它是在Java源文件中有效，在编译程序时编译器会忽略这些注射信息，我会将其注释到class字节码文件中去。
‌截图
Java中的注释有三种类型，具体如下：
        单行注释：通常用于对程序中的某一行代码进行解释，用符号“//”，“//”后面为被注释的内容。
        多行注释：顾名思义就是在注释中的内容可以为多行，它以符号“/*”开头，以符号“*/”结尾。
        文档注释：以“/**”开头，并在注释内容末尾以“*/”结束。

Java中的标识符

在编程过程中，经常需要在程序中定义一些符号来标记一些名称，如：包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。

标识符可以由任意顺序的大小写字母、数字、下划线、(_)和美元符号（$）组成，但不能以数字开头，不能是Java中的关键字。

定义标识符还应对应一下规则：

  1. 包名所有字母一律小写。例如：cn.itcast.test。
  2. 类名和接口名每个单词的首字母都要大写。如AeeayList、lterator。
  3. 常量名所有字母都要大写，单词之间用下划线连接。例如：DAY_OF_MONTH。
  4. 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getlineNumber。
  5. 在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。

Java中的关键字

关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。和其他语言一样，Java中保留了许多关键字，例如，class、public等，

Java中常量

常量就是在程序中固定不变的值，是不能改变的数据。

在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等

1、整型常量

整型常量是整数类型的数据，它的表现形式有四种，具体如下:
二进制:由数字0和1组成的数字序列，如:00110101。
八进制:以0开头并且其后由0~7范围(包括和7)内的整数组成的数字序列如:0342。
十进制:由数字0~9范围(包括和9)内的整数组成的数字序列。如:198。整数以十进制表示时，第一位不能是0，0本身除外
十六进制:以ox或者ox开头并且其后由0~9、A~F(包括0和9、A和F)组成的数字序列，如0x25AF。

2、浮点数常量

浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。其中，单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何的后缀，此时虚拟机会默认为double双精度浮点数。浮点数常量还可以通过指数形式来表示。具体示例如下:

2e3f  3.6d  0f  3.84d  5.022e+23f

3 、字符常量

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号 (") 引起来，它可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。具体示例如下:

'a' '1' '&' '\r' '\u0000'

 上面的示例中，"\u0000表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示是因为，Java采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为\u0000'

4.字符串常量

字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号("  ")引起来，引号要用英文符号。具体示例如下:

"HelloWorld" "123"  "Welcome\ n XXX" " "

一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为零。

5.布尔常量

布尔常量即布尔型的两个值true和false，该常量用于区分一个事物的真与假。

6.null常量

null常量只有一个值null，表示对象的引用为空。

2.2Java中的变量

变量的定义

在程序运行期间，随机可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识就是变量名，内存单元中存储的数据就是变量的值。

右边的代码中，第一行代码的作用是定义了两个变量x和y，也就相当于分配了两块内存单元，在定义变量的同时为变量x分配了一个初始值0，而变量y没有分配初始值，变量x和y在内存中的状态如图所示。

变量的数据类型

Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量通一种类型的值，否则程序会报错。

1. 整数类型变量

  • 用来存储整数数值，即没有小数部分的值。
  • 整数类型分为4种不同的类型：字节型(byte),短整型（short）,整型（int）和长整型（long）。

  • 占用空间指的是不同类型的变量分别占用的内存大小。
  • 取值范围是变量存储的值不能超出类型的范围，如果超出取值范围将会报错。

long类型：

当定义整数常量的时候，一般用long类型在数值后面用加字母“L”（或小写“l”）。

2.浮点数据类型

  • 浮点数类型变量用来存储小数数值。
  • 浮点数类型分为两种：单精度浮点数（float)，双精度浮点数（double)，double型所表示的浮点数比float型更精确。

  •  float在为一个float类型的变量赋值时需要注意一点。所复制的后面一定要加上字母“F”（或“f”），而为double类型的变量赋值时，可以在所复制的后面加上字母“D”（或“d”）， 也可不加。

  •  在程序中也可以为一个浮点类型变量赋予一个整数数值；但是一个整数不可以赋予一个浮点类型。

3.字符类型变量

用于存储一个单一字符，在Java中用char表示。
每个char类型的字符变量都会占用两个字节。
赋值时要用英文半角格式的单引号（' '）把字符括起来，如'a'。
也可以赋值为0~65535范围内的整数。计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。 

 4.布尔类型变量

布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。示例如下：

 变量，数据类型以及赋值，就构成了变量定义的三要素。

变量的类型转换

当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
根据转换方式的不同，数据类型转换可分为两种:自动类型转换和强制类型转换。(布尔类型不包括)
声明：
布尔类型不参与其中的转换，因为我们说过布尔类型的值只有两个值，所以它不能和其他类型混在一起使用要显式地进行声明

1.自动类型转换

也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。
第一是两种数据类型彼此兼容，
第二是目标类型的取值范围大于源类型的取值范围。

byte b = 3:.int x= b; 
// 程序把 byte类型的变里b转换成了int 类型，无须特殊声明

 自动类型转换就是把小的转换成大的数

(1) 整数类型之间可以实现转换，如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给intlong类型的变量，int类型的数据可以赋值给long类型的变量(2) 整数类型转换为float类型，如byte、char、short、int类型的数据可以赋值给float类型的变量。
(3) 其它类型转换为double类型，如byte、char、short、int、longfloat类型的数据可以赋值给double类型的变量。

2.强制类型转换

强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明
当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。

强制类型转换的格式如下所示:

目标类型    变量  =（目标类型）值

（注意）在对变量进行强制类型转换时，会发生取值范围较大的数据类型向取值范围较小的数据类型的转换，如将一个int类型的数转为byte类型，这样做极容易造成数据精度的丢失。

变量的作用域

变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。如果超出大括号范围，就会无效。（变量的作用域在编程中尤为重要）
​双引号内部的是直接输出的，+就是说出多个内容起个连接作用，x表示x变量的值

2.3java中的运算符

算术运算符

算术运算符就是用来处理四则运算的符号，这是最简单，最常用的运算符号。

  1.  在进行自增（++）和自减（--）的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面。则是先进行其他运算再进行自增或自减运算。
  2. 在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果也是一个小数。
  3. 在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。

赋值运算符

赋值运算符的作用就是将常量，变量或表达式的值赋给某一个变量，表中列出Java中赋值运算符及用法

 1. 在Java中可以通过一条赋值语句对多个变量进行赋值

2. 除了“=”，其他都是特殊的赋值运算符，

在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，需要进行强制类型转换。在使用+=，-=，*=，/=,%=运算进行赋值时，强制类型转换自动完成，程序不需要做任何显式地声明。

比较运算符

比较运算符用于两个数值或变量进行比较，结果就是一个布尔值，即true或false

 比较运算符在使用时需要注意一个问题，不能将比较运算符“==”误写成赋值运算符“=”。

逻辑运算符

​逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型。
在使用逻辑运算符的过程中，需要注意以下几个细节:
(1)逻辑运算符可以针对结果为布尔值的表达式进行运算。如:x >3 &&y!=0。
(2)运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。当运算符“&”和“&&”的右边为表达式时，两者在使用上还有一定的区别。在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用“&&”进行运算，当左边为false时，右边的表达式不会进行运算，因此“&&”被称作短路与。
(3) 运算符“”和“|”都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false同与操作类似，“I1”表示短路或，当运算符“1”的左边为true时，右边的表达式不会进行运算
(4)运算符“^”表示异或操作，当运算符两边的布尔值相同时 (都为true或都为false)，其结果为false。当两边布尔值不相同时，其结果为true。
与符号两边是真其整体结果就是真，或符号运算符只要有一者为真，结果就为真。非符号非真即假，非假即真。异或符号相同为假不同为真，短路与 当第一个表达式为假时则不会去判断第二个表达式，直接输出结果。

运算符的优先级

在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，把这种顺序称作运算符的优先级。

 案例代码：

 
 
/*
 * 商城库存清单案例
 * 变量的形式对商品的数据保存
 * 品牌，尺寸大小，价格，配置，库存数量
 * 三个商品 苹果，thinkpad,华硕
 * 
 * 计算出总的库存数，和商品的总金额
 */
public class Souhn {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  
  //苹果笔记本电脑
  String macBrand = "MacBookAIR";
  double macSize = 13.3;
  double macPrice = 5998.99;
  String macConfig = "i5处理器4GB内存128GB固体硬盘";
  int macCount = 5;
  
  //联想Thinkpad笔记本电脑
  String thinkpadBrabd = "ThinkpadT450";
  double thinkpadSizs = 14.0;
  double thinkpadPrice = 5999.99;
  String thinkpadConfig = "i5处理器4GB内存500G硬盘";
  int thinkpadCount = 10;
  
  //华硕笔记本电脑
  String ASUSBrand = "ASUS-FL5800";
  double ASUSSize = 15.6;
  double ASUSPrice = 4999.50;
  String ASUSConfig = "i7处理器4G内存128G固态硬盘";
  int ASUSCount = 18;
  
  //列表的顶部
  System.out.println("------------------------------商城库存清单------------------------------");
  System.out.println(" 品牌型号          尺寸        价格            配置                 库存数");
  
  //列表的中部
  System.out.println(macBrand + "      "+macSize + "      "+macPrice + "   "+macConfig+"     "+macCount);
  System.out.println(thinkpadBrabd + "    "+thinkpadSizs + "      "+thinkpadPrice + "   "+thinkpadConfig+"        "+thinkpadCount);
  System.out.println(ASUSBrand + "     "+ASUSSize + "      "+ASUSPrice + "    "+ASUSConfig+"      "+ASUSCount );
  
  //统计总库存数 总库存金额
  int totalCount = macCount + thinkpadCount + ASUSCount;
  double totalMoney = (macPrice*macCount)+(thinkpadPrice*thinkpadCount)+(ASUSPrice*ASUSCount);
  
  //列表底部
  System.out.println("---------------------------------------------------------------------");
  System.out.println("总库存是:"+totalCount);
  System.out.println("库存商品总金额:"+totalMoney);
 }
 
}

结果如下：

2.4选择结构语句

if条件语句:

if语句是指如果满足某种条件，就进行某种处理，其语法格式如下：

if{条件语句}{//当条件语句为真的时候就执行代码块,当条件语句为假的时候就什么都不执行

代码块

}

if语句执行流程如下：

if…else语句

if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理，语法格式如下：

f（判断条件）{

        执行语句1

        --

}else{

        执行语句2

        --

}

if…else if…else语句

if…else if…else语句用于对于多个条件进行判断，进行多种不同的处理，其语法格式如下：

if(判断条件1){//为真走语句1，为假往后走
    执行语句1
}else if(判断条件2){//条件为真走语句2，为假往后走
    执行语句2
}
...
else if(判断条件n){
    执行语句n
}else{
    执行语句n+1
}
 

if…else if…else语句的执行流程图如下：

 switch条件语句

 switch条件语句也是一种很常见的选择语句。和if条件语句不同，它只能针对某个表达式的值做出判断，从而决定执行哪一段代码。

 在switch条件语句中，使用 switch关键字来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句， switch语句的基本语法如下：

switch(表达式）{
case 目标值1：
    执行语句1
    break；
case 目标值2：
    执行语句2
    break；
……
case 目标值n：
    执行语句n
     break；
default:
    执行语句n+1
     break；
 

/*
 * Switch语句
 */
public class Tdshj {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int week = 8;
  switch(week) {
  case 1:
   System.out.println("星期一");
   break;
  case 2:
   System.out.println("星期二");
   break;
  case 3:
   System.out.println("星期三");
   break;
  case 4:
   System.out.println("星期四");
   break;
  case 5:
   System.out.println("星期五");
   break;
  case 6:
   System.out.println("星期六");
   break;
  case 7:
   System.out.println("星期日");
   break;
   default:
    System.out.println("输入的数字不正确...");
    break;
    
  }
  
  
  
 }
 
}

 结果如下：

  1.  switch语句中的表达式只能是byte、short、char、int、枚举（JDK1.5引入的）、String类型（JDK1.7引入的）的值，如注意:
  2. case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。
  3. break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止 switch语句的执行。
  4. 在一些特殊情况下，多个不同的case值执行一组相同的操作，这时可以不用break果传入其他值，程序会报错。在使用 switch语句的过程中，如果多个case条件后边的执行语句是一样的，则该执行语句只需要书写一次即可。

2.5循环结构语句

while循环语句

while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。 语法结构如下：

while）循环条件）{

        执行语句

        ……

}

 

 do…while循环语句

 do…while循环语句和while循环语句功能类似，语法结构如下：

do{

        执行语句

        ……

}while（循环条件）；

 for 循环语句

 for 循环语句是最常用的循环语句，一般用在循环次数已知的情况下，格式如下：

for（初始化表达式；循环条件；操作表达式）{

        执行语句

        ……

}

for后面的（）中包括三部分内容，初始化表达式，循环条件和表达式，它们之间用“；”分隔，{}中的执行语句为循环体

在for循环里执行都有严格的顺序限制的,第一步执行初始化表达式，第二步执行循环条件如果判断为真，执行第三步，判断为假执行第五步。第三步执行循环体。第四步执行操作表达式，然后执行第二步，第五步退出循环。

循环嵌套

嵌套循环是指一个循环语句的循环体再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以相互嵌套，最常见的在for循环中嵌套for循环

/*
 * for循环(使用*打印直角三角形)
 */
public class Ghj {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int i,j;//定义两个循环变量
  for(i = 1;i<=9;i++) {//外层循环
   for(j = 1;j<=i;j++) {//内层循环
    System.out.print("*");//输出
   }
   System.out.print("\n");//换行
  }
 
 }
 
}

结果如下：

跳转语句（break,continue）

跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句

1.break语句：用在Switch条件语句和循环语句中，它的作用是终止某个case并跳转Switch结构。

2.continue语句：用在循环语句中，它的作用是终止本次循环，执行下一次循环

案例：

/*
 * continue语句
 */
public class Contiu {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int sum = 0;//定义变量sum，用于记住和
  for(int i=1;i<=100;i++) {
   if(i%2==0) {//i是一个偶数，不累加
    continue;//结束本次循环
   }
   sum += i;//实现sum和i的累加
  }
  System.out.println(sum);
 }
 
}

 结果如下：

break案例：

/*
 * break语句
 */
 
public class Hello{
 public static void main(String[] args) {
  int x=1;//定义变量x，初始化值为1
  while(x<=4) {//循环条件
   System.out.println("x="+x);//条件成立，打印x的值
   if(x==3) {
    break;
   }
   x++;//x进行自增
  }
 }
}

结果如下：

/*
 * break语句（跳出外层循环）
 */
public class Hello{
 public static void main(String[] args) {
  int i,j;//定义两个循环变量
  incast:for(i=1;i<=9;i++) {//外层循环
   for(j=i;j<=i;j++) {//内层循环
    if(i>4) {
     break incast;
    }
    System.out.print("*");//打印
   }
   System.out.println("\n");//换行
  }
 }
}

结果如下：

猜数字游戏案例：

import java.util.Random;
import java.util.Scanner;
public class Hello {
 
 public static void main(String[] args) {
  //1、通过RANDOM类中的nextInt（n）方法，生成一个0-9之间的随机数
  int randomNumber =new SecureRandom().nextInt(10);
  System.out.println("随机数已生成！");
  //2、输入猜的数字
  System.out.println("----请输入您猜的数字:-----");
  Scanner sc=new Scanner(System.in);
  int enterNumber=sc.nextInt();
  //3、通过while循环，进行猜数字对错判断
  while(enterNumber!=randomNumber) {
   //猜错了，根据结果，给出提示，接着猜数字，游戏继续
   if(enterNumber>randomNumber) {
   //如果猜大了，打印sorry,您猜大了！继续下一次循环
    System.out.println("sorry,您猜大了！");
   }
   else {
    //如果猜小了，打印sorry,您猜小了！继续下一次循环
    System.out.println("打印sorry,您猜小了！");
   }
   //输入猜的数字
   System.out.println("-----请输入您的数字：-------");
   enterNumber=sc.nextInt();
  }
  System.out.print("恭喜您，答对了！");
 }
}

结果如下：

2.6方法

目录

2.1.java的基本语法

Java中的注释

Java中的标识符

Java中的关键字

​编辑Java中常量

1、整型常量

2、浮点数常量

3 、字符常量

4.字符串常量

5.布尔常量

6.null常量

2.2Java中的变量

变量的定义

变量的数据类型

1. 整数类型变量

long类型：

2.浮点数据类型

3.字符类型变量

 4.布尔类型变量

变量的类型转换

1.自动类型转换

2.强制类型转换

变量的作用域

2.3java中的运算符

算术运算符

赋值运算符

比较运算符

逻辑运算符

运算符的优先级

2.4选择结构语句

if条件语句:

if…else语句

if…else if…else语句

 switch条件语句

2.5循环结构语句

while循环语句

 do…while循环语句

 for 循环语句

循环嵌套

跳转语句（break,continue）

2.6方法

什么是方法

方法的重载

2.7数组

数组的定义

1.数组遍历

2.数组最值

3.数组排序

多维数组

什么是方法

假如在一个程序里需要重复的编写100行代码，这样程序就会变得很臃肿，可读性也非常差。所以我们需要把这100行代码抽取出来放在一个地方,在Java里面可以放在一个大括号里面,规定一个范围在这个范围里取个名字就叫做“方法”,当你想运行的时候只要拿出来用就可以了,这个时候你的程序就会变得设计的很好，代码的重复问题也得到了解决，阅读性增强,需要的时候调用那个方法即可。方法可以看作是一个完成一个功能的，具有独立性的代码的一个小片段,片段的范围就是Java中大括号里的范围。

/*
 * 不适用方法时实现打印三个长宽不同的矩形
 */
public class Ff {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //下面的循环是使用*打印宽为5，高为3的矩形
  for(int i = 0; i<3 ; i++) {
   for(int j = 0;j < 5; j++) {
    System.out.print("*");
   }
   System.out.print("\n");
  }
  //下面的循环是使用*打印宽为4，高为2的矩形
  for(int i = 0; i < 2; i++){
   for(int j = 0; j < 4; j++) {
    System.out.print("*");
   }
   System.out.print("\n");
  }
  //下面的循环是使用*打印宽为10，高为6的矩形
  for(int i = 0;i < 6; i++){
   for(int j = 0;j < 10; j++) {
    System.out.print("*");
   }
   System.out.print("\n");
  }
 }
 
}

结果如下：

在Java中，声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名（[参数类型 参数名1，参数类型 参数名2……]){

        执行语句

        ……

return 返回值；

}

  • 修饰符：是对访问权限的限定，例如，public、static都是修饰符
  • 返回值类型：用于限定方法返回值的数据类型
  • 参数类型：用于限定调用方法时传入参数的数据类型
  • 参数名：是一个变量，用于接收调用方法时传入的数据
  • return关键字：用于结束方法以及返回方法指定类型的值
  • 返回值：被return语句返回的值，该值会返回调用者
  • 方法名首字母需要大写
/*
 * 使用有返回值的方法求矩形面积
 */
public class FangDing {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int area = getArea(3,5);//调用getArea方法
  System.out.println("The area i7" +  area);//输出
 }
 //下面定义了一个求矩形面积的方法，姐收两个参数，其中x为高，y为宽
 private static int getArea(int i, int j) {
  // TODO Auto-generated method stub
  return i * j;
 }
 
}

结果如下：

方法的重载

案例：

/*
 * 调用不同的方法
 */
public class Fangf {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //下面针对求和的方法调用
  int sum1 = add01(1,2);
  int sum2 = add02(1,2,3);
  double sum3 = add03(1,2);
  //下面的代码是打印求和的结果
  System.out.println("sum1="+sum1);
  System.out.println("sum2="+sum2);
  System.out.println("sum3="+sum3);
 }
 //下面的方法实现两个小数相加
 private static double add03(double i, double j) {
  // TODO Auto-generated method stub
  return i+j;
 }
 //下面方法实现了三个整数相加
 private static int add02(int i, int j, int k) {
  // TODO Auto-generated method stub
  return i+j+k;
 }
 //下面的方法实现两个数整数相加
 private static int add01(int i, int j) {
  // TODO Auto-generated method stub
  return i+j;
 }
 
}

 结果如下：

java 允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同，（个数不一样，类型不一样，顺序不一样也是重载），这就是方法的重载。（方法名相同，但是这个参数列表不一样）重载和前面的内容没有关系，返回值没关系修饰符也没关系。只和方法名和参数列表有关系。

2.7数组

数组的定义

数组是指一组数据的集合，数组中的每个元素被称为元素，在数组中可以存放任意类型的元素，但同一个数组中存放的元素类型必须一致。

在Java中可以使用以下格式定义一个数组:

int []x=new int [100];

上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。

在Java中，为了更方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length"的方式来获得数组的长度，即元素的个数。

当数组被成功创建后，数组元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。

在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式：

1.类型[] 数组名=new类型[]元素，元素，……}；

2.类型[] 数组名={元素，元素，元素，……}；

 案例：

/*
 * 定义数组以及访问数组中的元素
 */
public class Dmi {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int[] arr;//声明变量
  arr = new int[100];//创建数组的容器
  System.out.println("arr[0]="+arr[0]);//访问数组中的第一个元素
  System.out.println("arr[1]="+arr[1]);//访问数组中的第二个元素
  System.out.println("arr[2]="+arr[2]);//访问数组中的第三个元素
  System.out.println("数组的长度是："+arr.length);//输出数组的长度
 }
 
}

 结果如下：

1.数组遍历

在操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数组的遍历。

索引思想，操作数组中的元素，赋值还是获取值，都是依赖索引  arr［0］
索引思想：操作数组。arr［0］赋值，获取
循环：循环的变量，从0开始，每次递增。

/*
 * for循环遍历数组
 */
public class Ujs {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int[] arr =  {1,2,3,4,5};//定义数组
  //使用for循环遍历数组的元素
  for(int i = 0;i<arr.length;i++) {
   System.out.println(arr[i]);//通过索引访问元素
  }
 }
 
}

结果如下：

 

2.数组最值

在操作数组时，经常需要获取数组中元素的值

在数组中会有很多个元素，我们要在众多个元素中找出数组中的最大值是谁。

3.数组排序

在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。

数组排序的过程如下所示：

  • 从第一个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第一个元素比后一个大，则交换位置。整个过程完成后，数组中最后一个元素就是最大值。（相邻的两个元素进行比较换位）（数组元素换位：临时变量）
/*
 * 冒泡排序
 */
public class Maopao {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int[] arr = {9,4,5,3,7};//定义数组，赋值无序
  System.out.println("冒泡排序前：");
  pintArray(arr);//输出数组元素
  bubbleSort(arr);//调用排序的方法
  System.out.println("冒泡排序后：");
  pintArray(arr);//输出数组元素
 }
 //定义打印数组的元素的方法
 public static void pintArray(int[] arr) {
  //循环遍历数组的元素
  for(int i=0;i<arr.length;i++) {
   System.out.print(arr[i] + "  ");//输出元素和空格
  }
  System.out.print("\n");
 }
 //定义对数组排序的方法
 public static void bubbleSort(int[] arr) {
  //定义外层循环
  for(int i = 0;i < arr.length - 1;i++) {
   //定义内层循环
   for(int j = 0;j<arr.length -i -1;j++) {
    if(arr[j]>arr[j+1]) {//比较相邻的元素
     //
     int temp = arr[j];
     arr[j] = arr[j+1];
     arr[j+1]=temp;
    }
   }
  }
 }
 
}

 结果如下：

  1. 除最后一个元素，将剩余的元素继续进行两两比较，过程与第一步类似，这样数组第二大的元素放在了倒数第二个位置
  2. 以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一个元素需要比较为止

/*
 * 获取数组中的最大值
 */
public class Rji {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int[] arr = {4,1,16,3,9,8};//定义一个数组
  int max = getMax(arr);//调用获取最大值的方法 
  System.out.println("max="+max);//输出最大值
 }
 
 private static int getMax(int[] arr) {
  // TODO Auto-generated method stub
  int max = arr[0];//定义变量max用于记住最大值。首先保存数组中的第0个索引上的元素
  //下面通过一个for循环遍历数组中的元素
  for(int x=1;x<arr.length;x++) {
   if(arr[x]>max) {//比较arr[x]的值是否大于max
    max=arr[x];//条件成立，将arr[x]的值赋值给max
   }
  }
  return max;//返回最大值
 }
 
}

 运行结果：

多维数组

多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组。

二维数组的定义有很多方式，如下：

int [] [] arr=new int [3] [4];

  上面代码定义了一个3行4列的二维数组，结构如下：

 方式二：

int [] [] arr=new int [3] [];

 上述方法与第一种方法类似，只是数组中每个元素的长度不确定，采用第二种方式常见的数组结构如下：

 方式三：

int [] [] arr={{1,2},{3,4,5,6},{7,8,9}};

 上述方式定义的二维数组三个元素，这三个元素都是数组，分别是{1,2}、{3,4,5,6}、{7,8,9}。

通过一张图来描述方式三定义的数组结构：

 二维数组的访问同样也是通过索引去访问的

/*
 * 二维数组的使用
 */
public class Dhj {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int [] [] arr = new int[3] [];//定义一个长度为3的二维数组
  arr[0] = new int[] {11,12};//为数组的元素赋值
  arr[1] = new int[] {21,22,23};
  arr[2] = new int[] {31,32,33,34};
  int sum = 0;//定义变量记录总销售额
  for(int i =0;i<arr.length;i++) {
   int gropuSum = 0;//定义变量记录小组的销售额
   for(int j = 0;j<arr[i].length;j++) {
    gropuSum = gropuSum+arr[i][j];
   }
   sum = sum + gropuSum;
   System.out.println("第"+(i+1)+"小组销售额为:"+gropuSum+"万元");
  }
  System.out.println("总销售额为:"+sum+"万元");
 }
 
}

 运行结果：

 随机点名案例：

/*
 * 随机点名器
 * */
 
import java.security.SecureRandom;
import java.util.Scanner;
public class Bhs {
 
   // 1、存储全班同学的姓名 创建一个存储多个同学的姓名的容器（数组）
   // 键盘录入每个同学的姓名，存储到数组容器中
   
 
 public static void addStudentName(String[]students) {
  //键盘录入多个同学姓名存储到容器中
  Scanner sc =new Scanner (System.in);
  for(int i=0;i<students.length;i++){
   System.out.println("存储第"+(i + 1)+"个姓名：");
   students[i]=sc.next();
  }
}
 // 2、总览全班同学姓名
  
 public static void printStudentName(String[]students) {
  //遍历数组，得到每个同学姓名
  for(int i=0;i<students.length;i++) {
   String name =students[i];
   System.out.println("第"+(i+1)+"个学生姓名："+name);
  }
 }
 // 3、随机点其中一人
  
 public static String randomStudentName(String[] studrents) {
  //根据数组产孤独，获取随机数
  int index =new SecureRandom().nextInt(studrents.length);
  //通过随机索引从数组中获取名字
  String name =studrents[index];
  return name;
 }
 
public static void main(String[]args) {
 System.out.println("-----随机点名器--------");
 String[] students=new String[3];
 addStudentName(students);
 printStudentName(students);
 String randomName=randomStudentName(students);
 System.out.println("被点到名字的同学是："+randomName);
 
}
}

运行结果：

 

三月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础知识复习资料.doc
04-22
Java是一种广泛使用的面向对象编程语言，它以其强大的功能和易用性著称。Java的特点在于它的设计者吸取了C++的优点，同时摒弃了复杂的多继承和指针等概念...对于初学者而言，掌握这些基础知识点是学习Java编程的关键。
Java基础知识点复习资料.zip
06-05
1. **Java环境配置**：安装Java Development Kit (JDK) 是开始编程的第一步。理解`JAVA_HOME`环境变量的设置，以及如何配置`Path`变量以确保编译器`javac`和运行时环境`java`在命令行中可访问。 2. **Java语法基础*...
第一篇Java基础知识复习
yyjy12的博客
03-27 79
第一篇Java基础知识复习
第一篇java基础知识复习
weixin_73281971的博客
03-28 129
Java基础知识复习
m0_50447364的博客
04-30 2723
文章目录前言一、Java 概念与常识Java 语言有哪些特点?JVM vs JDK vs JREJVMJDK 和 JRE字节码二、基本语法字符型常量和字符串常量的区别?标识符和关键字的区别是什么？Java 语言关键字有哪些？自增自减运算符continue、break 和 return 的区别是什么？方法什么是方法的返回值?方法有哪几种类型？静态方法为什么不能调用非静态成员?总结 前言 随着Java技术的不断更新，我深知在学习新技术的同时，还要不不断总结之前学习的知识，并与新的知识融会贯通，做到举一反三。
第一篇Java基础知识复习博客
2301_76551149的博客
03-29 110
挑了些个人认为比较重要的知识点写在word里，方便后续记笔记。
一文带你复习java--java基础知识篇
wuhuanyicheng的博客
04-26 1万+
m字节序是指多字节数据在计算机内存中存储或网络传输时个字节的存储顺序。通常由小端和大端两组方 式。 1. 小端:低位字节存放在内存的低地址端，高位字节存放在内存的高地址端。 2. 大端：高位字节存放在内存的低地址端，低位字节存放在内存的高地址端。 Java语言的字节序是大 端方式。
Java基础知识点汇总
热门推荐
qq_41286666的博客
05-04 4万+
Java基础知识点汇总1. Java基础语法2. 面向对象3. 异常处理4. 集合5. IO流 1. Java基础语法 类型转换 // 强制类型转换 float a = 20.34f; int b = (int)a; //自动类型转换 int c = 10; float d = c; //操作较大的数时，注意溢出问题 //JDK7新特性，数字之间可以用下划线分割
java基础复习看这篇就够了
weixin_51654689的博客
11-08 3323
JDK的全称（java Development Kit java开发工具包）JDK=JRE+java开发工具【java，javac，javadoc，javap等】JDK是提供给java开发人员使用的，其中包含了java的开发工具，也包括了JRE。JRE（Java Runtime Environment java运行环境）JRE=JVM+Java的核心类库包括Java虚拟机和java程序所需的核心类库等，如果想要运行好的java程序，计算机中只需安装JRE即可。
Java知识复习（八）Spring基础
qq_44648936的博客
03-01 3684
Spring相关的基础知识
JAVA期末复习知识点总结大全
RuanFun的博客
06-22 1万+
答：Lambda表达式是Java中表达匿名函数的方法，可以使得编程中的代码更简洁。（可以将Lambda表达式理解为一种没有函数名的函数）参数列表：它定义了函数的输入参数。这些参数的数量和类型可以根据需要定义，如果没有参数，可以写成()。函数体：它定义了Lambda表达式要执行的操作。函数体可以是一个表达式，也可以是一组语句。箭头符号：->是Lambda表达式的核心，它将参数列表和函数体分隔开。(参数列表) -> {语句;
Java期末考试知识点复习
weixin_46028606的博客
07-08 6677
基本常识： 开发与运行Java程序三个步骤：编辑源程序，编译，解释运行字节码 一，面向对象 面向对象程序设计特性： 封装性，继承性，多态性 ★★★★★ Ⅰ。类 →类成员，static ①成员变量（属性）→实例成员，无static ②方法 →类方法，有static →实例方法，无static 方法重载：方法名相同，形参列表不同 ③构造器：用来初始化实例变量 super(。。。)=>父类构造器，子类构造器第一行！！ this(。。。) =>本类构造
Java常用基础知识-kaic.docx
07-14
Java 常用基础知识是程序员面试中不可或缺的部分，尤其对于准备进入阿里巴巴、腾讯、京东、百度、美团、去哪儿等互联网公司的求职者来说，掌握这些知识至关重要。以下是对这两个问题的详细解析： 1. 类加载问题：...
java基础知识复习资料
05-01
Java是一种强类型语言，这意味着在编写Java代码时，变量必须先声明并初始化...以上是对Java基础知识的一些关键点的详细解释，涵盖了类型系统、变量、访问控制和一些核心特性。这些内容对于理解Java编程的基础至关重要。
Java语言程序设计第10版（基础篇）复习题答案
06-24
《Java语言程序设计第10版（基础篇）》是一本深入浅出的Java编程教材，旨在帮助初学者掌握这门强大的面向对象编程语言。复习题答案提供了对每一章节核心概念的检验和巩固，帮助读者确认对每个主题的理解是否到位。...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 251
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 623
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 284
集合之Map
Java复习题：基础知识、特点和语法要点
首先，在第一题中，正确的叙述是： ①Java 是不区分英文字母大小写的，源文件名与程序类名不允许相同 这个问题主要是考察Java语言的语法规则，Java是一种区分大小写的语言，这意味着变量名、方法名等不区分大小写，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值