电子开发 | 基础入门 | 电路原理图

电子开发网

电子开发网电子设计 | 电子开发网Rss 2.0 会员中心 会员注册
搜索: 您现在的位置： 电子开发网 >> 编程学习 >> Java >> 正文

JAVA语法程序汇总_Java基础语法总结

作者：佚名    文章来源：网络整理    点击数：    更新时间：2024/2/25

Java基础语法
计算机基础
1.什么是二进制？
2.什么是字节？
3.命令提示符
Java语言基础
JRE和JDK、JVM
关键字和标识符
常量和变量
数据类型转换
运算符
程序流程
方法

Java基础语法

计算机基础

1.什么是二进制？

二进制数只包含0和1，每一个0或者1都是一个bit（位）。
我们常用的十进制如何转换成二进制：

 

2.什么是字节？

我们知道计算机中的数据都是由1或者0组成，每个0或1都是一个bit，每8个bit就是一个字节(byte）。
字节是数据存储的最小单位。
1 TB = 1024 GB---->1 GB = 1024 MB ---->1 MB = 1024 KB---->1 KB = 1024 B

3.命令提示符

启动：win+R
切换盘符： 盘符:
退出：exit
进入文件夹：cd+文件夹名称
查看目录：dir
清屏：cls
进入多级文件夹： cd+\IdeaProjects\javaBasic\java
返回上一层：cd…
返回根目录：cd </br>

Java语言基础

JRE和JDK、JVM

JRE(Java Runtime Enviroment),Java运行环境，如果只是需要在该计算机上运行Java应用，那么只需要安装JRE即可。

JDK(Java Development Kit),如果想要开发，就必须安装JDK。
 
特别注意：JDK安装路径最好不要有空格或者中文。

关键字和标识符

关键字的特点：

  1. 完全小写的字母
  2. 在增强版的记事本或者IDE中有特殊的颜色

标识符：自己命名的类名，方法名等。
命名规则：

  1. 由字母、数字、下划线、美元符号组成
  2. 不能由数字开头
  3. 不能是Java保留字

常量和变量

常量

什么是常量？
常量就是在程序运行期间，不会改变的量。

常量的分类
字符串常量：凡是用双引号括起来的都是字符串常量，例如：“abc”,“110”,“Hello”…
字符常量：凡是用单引号括起来的单个字符，就叫字符常量。例如：‘A’,‘a’,‘1’,‘张’
整型常量：直接写上的数字，没有小数点。例如：123,200，-23
浮点型常量：直接写上的数字，有小数点。例如：3.14,0.0
布尔常量：true或false
空常量：null。代表没有任何数据

public class Demo01Const{
 public static void main(String[] args){
  // 字符串常量 
  System.out.println("ABC");
  System.out.println("");
  System.out.println("XYZ");
  // 整数常量
  System.out.println(50);
  System.out.println(-30);
  // 浮点常量 
  System.out.println(3.14);
  System.out.println(0.0);
  System.out.println(-24.0);
  // 字符常量 
  System.out.println('A');
  System.out.println('a');
  //System.out.println('');单引号中间有且仅有一个字符，没有不行，编译出错
  // 布尔常量 
  System.out.println(true);
  System.out.println(false);
  //空常量 null,不能直接打印
 }
}
数据类型

数据类型分为两类：

  1. 基本数据类型：整型，浮点型，布尔型，字符型
  2. 引用数据类型：字符串，数组，类，接口，Lamda

基本数据类型：
整型：byte，short，int，long
浮点型：float，double
字符型：char
布尔型：boolean
 

基本数据类型注意事项：
1.字符串不是基本数据类型，而是引用类型。
2.浮点型可能是一个近似值，而不是精确值。
3.数据范围不一定与字节数相关，例如float的范围比long要广，但是它只占4个字节。
4.浮点数默认是double类型，要使用float类型，需要加上后缀F/f，但是建议使用F。
5.整数默认为int类型，要使用long类型，需要加上后缀L/l，但是建议使用L。

public class Demo01DataType{
 public static void main(String[] args){
  System.out.println(1024);//默认是int类型
  System.out.println(3.14);//默认是double类型
  //左边是long类型，右边是int类型，数据类型不一致，会发生数据转换，
  //int类型数据范围比long类型数据范围小，可以发生自动类型转换
  long num1 = 10;
  System.out.println(num1);
  //左边是double类型，右边是float类型，数据类型不一致，可以发生数据类型转换
  //float---->double float数据范围比double小，可以是发生自动类型转换
  double num2 = 2.5F;
  System.out.println(num2);
  //左边是float类型，右边是long类型，数据类型不一致，可以发生数据类型转换
  //long---->float long类型数据范围比float类型小，可以发生自动类型转换
  float num3 = 30L;
  System.out.println(num3);//30.0
 }
}
变量

什么是变量？
就是在程序运行期间，会发生改变的量。

创建一个变量的格式
① 数据类型 变量名称;//创建一个变量
变量名称 = 数据值;//赋值，将右边的数据值，赋值给左边的变量
② 数据类型 变量名称 = 数据值;

public class Demo02Variable{
 public static void main(String[] args){
  //使用格式①创建变量
  int num1;
  num1=1;
  System.out.println(num1);
  //改变变量当中的值
  num1=20;
  System.out.println(num1);
  //使用格式②
  int num2 = 5;
  System.out.println(num2);
  //byte num3 = 129;
  //System.out.println(num3);
  byte num3 = 64;
  System.out.println(num3);//64
  short num4 = 400;
  System.out.println(num4);//400
  long num5 = 3000000000L;
  System.out.println(num5);//3000000000
  float num6 = 3.2444F;
  System.out.println(num6);//3.2444
  double num7 = 3.14;
  System.out.println(num7);//3.14
  char ch1 = 'A';
  System.out.println(ch1);//A 
  char ch2 = '2';
  System.out.println(ch2);//2
  char ch3 = '我';
  System.out.println(ch3);//我
  boolean b1 = true;
  System.out.println(b1);//true
  b1 = false;
  System.out.println(b1);//false
  boolean b2 = b1;
  System.out.println(b2);//false
 }
}

使用变量的注意事项

  1. 变量的命名不能重复。
  2. 在使用byte和short的时候要注意它们的范围，如果超出范围会编译错误。
  3. 在使用float和long类型时，注意要加后缀。
  4. 变量的使用不能超出其作用域。（作用域：就是从变量命名的地方开始，直到该变量直接所属的大括号结束为止）
  5. 没有进行赋值的变量不能直接使用。
  6. 可以直接定义多个变量，但是不建议使用。
public class Demo03VariableNotice{
 public static void main(String[] args){
  int num1 = 10;
  System.out.println(num1);
  //int num1 = 20;错误，变量名不能重复。
  float num2 = 3.14F;//如果不加F会产生错误。
  System.out.println(num2);
  long num3 = 30000000000L;
  System.out.println(num3);
  //byte num4 = 128; 注意byte的范围是-128~127，不能超出范围
  byte num4 = 12;
  System.out.println(num4);
  short num5 = 400;
  System.out.println(num5);
  //没有赋值的变量不能使用
  //int num6;
  //System.out.println(num6);
  //此时还没有命名变量，无法使用。
  //System.out.println(num6);
  int num6 = 2;
  System.out.println(num6);
  //可以这么使用，但是不建议。
  int a = 10,b = 20,c = 30;
  System.out.println(a);
  System.out.println(b);
  System.out.println(c);
 }
}

数据类型转换

什么是数据类型转换？
当数据类型不一样时，就会发生数据类型转换。

数据类型转换的分类：

  1. 自动类型转换(隐式)：
    ①特点：代码不需要进行处理，自动完成
    ②规则：数据范围由小到大
public class Demo01DataType{
 public static void main(String[] args){
  System.out.println(1024);//默认是int类型
  System.out.println(3.14);//默认是double类型
  //左边是long类型，右边是int类型，数据类型不一致，会发生数据转换，
  //int类型数据范围比long类型数据范围小，可以发生自动类型转换
  long num1 = 10;
  System.out.println(num1);
  //左边是double类型，右边是float类型，数据类型不一致，可以发生数据类型转换
  //float---->double float数据范围比double小，可以是发生自动类型转换
  double num2 = 2.5F;
  System.out.println(num2);
  //左边是float类型，右边是long类型，数据类型不一致，可以发生数据类型转换
  //long---->float long类型数据范围比float类型小，可以发生自动类型转换
  float num3 = 30L;
  System.out.println(num3);//30.0
 }
}

2.强制类型转换(显式)：
①特点：代码需要进行格式处理，不能自动完成
②格式：数据类型 变量名称 = （范围小的类型）原本范围大的数据

注意事项：

  1. 强制类型转换有可能导致精度丢失、数据溢出等。
  2. byte、short、char类型都可以进行数学运算。
  3. byte、short、char类型在进行数学运算时，都被提升成了int类型，再进行计算。
  4. boolean类型不能进行数据转换。
public class Demo02DataType{
 public static void main(String[] args){
  //左边是int类型，右边是long类型，会发生数据类型转换
  //long---->int ,long类型范围比int类型大，不能发生自动类型转换，需要强制类型转换
  //进行格式处理： 范围小的数据类型  范围小的变量名 = (范围小的数据类型)原本范围大的数据；
  int num =(int)100L;
  System.out.println(num);
  //左边是int类型，右边是long类型，会发生数据类型转换
  //long--->int long比int范围要大，所以发生强制类型转换
  //但是发生了数据溢出，因为int类型装不下6000000000
  int num1 = (int) 6000000000L;
  System.out.println(num1);//1705032704
  //float---->int 强制转换，发生精度丢失，这里不是四舍五入
  int num2 = (int) 3.99F;
  System.out.println(num2);//3
  //我们都知道计算机底层都是二进制数，所以A也是以二进制数的形式来存储，
  char ch1 = 'A';
  System.out.println(ch1+1);//66  证明这里的'A'被当做65来进行运算
  byte b1 = 40;
  byte b2 = 50;
  int result1 = b1+b2;//会报错，不兼容的类型。原因：就是第三个注意事项，当进行数学运算时，b1和b2都已经被提升成了int类型，左右两边类型不一致
  //需要发生强制类型转换，所以把result1的类型转换成int
  System.out.println(result1);
  short s1 = 60;
  //short result2 = b1+s1;    同上，会报错，如果想要的结果是short类型，那么必须进行强制类型转换
  short result2 =(short)(b1+s1);
  System.out.println(result2);
 }
}
ASCII码表

什么是ASCII码表？
ASCII：American Standard Code of Information Inchange 美国信息交换标准代码
还有Unicode表，就是数字和字符的对照关系表。

public class Demo03DataTypeChar{
 public static void main(String[] args){
  char ch1 = '1';
  System.out.println(ch1+0);
  char ch2 = 'A';
  System.out.println(ch2+2);//67
  //左边是int类型，右边是char类型，左右不一致，发生数据类型转换
  //char---->int 范围小向范围大转换，自动转换，不需要强制类型转换
  int num = 'c';
  System.out.println(num);//99
  int ch3 = '中';
  System.out.println(ch3);//20013
 }
}

运算符

什么是运算符？
就是进行特定操作的符号。
什么是表达式？
就是用运算符连接起来的式子。

四则运算符和加号的特定用法

四则运算符，+，-，*,/,%;其中包括加，减，乘，除，%代表取模，即取余数。

public class Demo04Operator{
 public static void main(String[] args){
  System.out.println(20+30);//50
  int a = 10;
  int b = 20;
  //会先计算表达式的值，再进行打印
  System.out.println(a-b);//-10
  System.out.println(a*10);//100
  //除法，只看商
  int result1 = 10/3;
  System.out.println(result1);//3
  //如果想要获得余数，用取模运算
  int x = 14;
  int y = 3;
  int result2 = x%y;
  System.out.println(result2);//2
  //int + double ---->double + double ----->double 
  double result3 = x + 2.5;
  System.out.println(result3);//16.5
 }
}

"+"常见的三种用法：

  1. 正常的加法运算
  2. 对于char类型来说，在计算前会被提升为int类型
  3. 用于连接字符串（注意事项：任何数据类型和字符串相连接，都会变成字符串)
public class Demo05Plus{
 public static void main(String[] args){
  String str1 = "Hello";
  System.out.println("Hello");
  System.out.println("Hello"+"World");//HelloWorld
  String str2 = "Java";
  //String + int --->String + String ---->String 
  System.out.println(str1+20);//Java20
  System.out.println(str1+20+30);//Java2030
  System.out.println(str1+(20+30));//Java50
 }
}
自增、自减运算符

使用方式：++可以在前，也可以在后，例如：++n或者n++。
使用区别：
1.单独使用：++在前和在后没有任何区别，独自形成一个步骤（前提是不与任何其他操作混合）
2.混合使用：当混合使用时，++在前和在后有【重大区别】：
a.++在前时，变量立刻+1，然后再参与其他运算 【先加后用】
b.++在后时，变量首先按照原来的值参与其他运算，然后再+1 【先用后加】
注意事项：只有是变量才能使用自增、自减符号，常量无法使用。

public class Demo06Operator{
 public static void main(String[] args){
  //单独使用的情况，没有区别
  int num1 = 10;
  ++num1;
  System.out.println(num1);//11
  int num2 = 20;
  num2++;
  System.out.println(num2);//21
  System.out.println("==============================================================");
  //混合使用，例如与打印操作混合
  int num3 = 30;
  System.out.println(++num3);//31
  System.out.println(num3);//31
  int num4 = 40;
  System.out.println(num4++);//40
  System.out.println(num4);//41
  System.out.println("==============================================================");
  //和赋值操作混合
  int num5 = 50;
  int result1 = num5++;
  System.out.println(result1);//50
  System.out.println(num5);//51
  int num6 = 60;
  int reuslt2 = --num6;
  System.out.println(reuslt2);//59
  System.out.println(num6);//59
  System.out.println("==============================================================");
  int x = 10;
  int y = 20;
  int result = --x + y++;
  System.out.println(result);//29
  System.out.println(x);//9
  System.out.println(y);//21
  //30++; //只有变量才能自增或自减，常量使用会编译报错。
 }
}
赋值运算符

1.基本赋值运算符
就是=，代表把右边的数据值赋值给左边的变量
2.复合赋值运算符
+=： a += 5 相当于 a = a + 5;
-=： a -= 5 相当于 a = a - 5;
*=： a *= 5 相当于 a = a * 5;
/=： a /= 5 相当于 a = a / 5;
%=： a += 5 相当于 a = a % 5;

注意事项：
1.只有变量可以使用复合赋值运算，常量不可以使用。
2.复合赋值运算实际含有一个隐式的数据类型转换。

public class Demo07Operator{
 public static void main(String[] args){
  int a = 10;
  a += 5;
  System.out.println(a);//15
  int b = 13;
  b %= 4;
  System.out.println(b);//1
  //复合赋值运算中隐含了一个强制类型转换
  byte x = 12;
  //x += 5; 
  //相当于 x = x + 5;
  // byte  = byte + int ;
  //byte =  int + int ;
  //byte = int ;
  //byte = (byte)int;
  x += 5;
  System.out.println(x);//17
 }
}
比较运算符

比较运算符： > , < , >= , <= , == ,!=;
注意事项：
1.比较运算符的结果一定是boolean类型。
2.如果进行多次判断，不能像数学中连写，如1<x<3,这样会编译报错。

public class Demo08Operator{
 public static void main(String[] args){
  int x = 10;
  int y = 20;
  System.out.println(x > y);//false
  System.out.println(x < y);//true;
  System.out.println(x >= 100);//false
  System.out.println(x <= 10);//true;
  System.out.println(10 == 10);//true 
  System.out.println(20 != 20);//false
 }
}
逻辑运算符

与：&&;
或：||;
非：!;

与、或具有短路效果：就是根据左边的表达式已经能够判断出结果，那么后边的表达式将不再运行，节省性能。

public class Demo09Logic{
 public static void main(String[] args){
  System.out.println(true && true);//true
  System.out.println(true && false);//false
  System.out.println(3 < 4 && 10 < 100);//true
  System.out.println(true || true);//true
  System.out.println(true || false);//true
  System.out.println(false || false);//false
  System.out.println(!true);//false
  System.out.println(!false);//true
  System.out.println("======================");
  //短路效果： 
  int a = 10;
  System.out.println(3 > 4 && ++a > 1);//false
  System.out.println(a);//10
  int b = 20;
  System.out.println(3 < 4 || b++ > 1);//true
  System.out.println(b);//20
 }
}
三元运算符

格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B；

注意事项：
1.表达式A和表达式B必须同时满足左边的数据类型，否则编译报错。
2.三元运算符的结果必须被使用，要么赋值，要么打印等，不能独立存在

public class Demo10Operator{
 public static void main(String[] args){
  int a = 10;
  int b = 20;
  int max = a > b ? a : b;
  System.out.println("最大值是：" + max);//20
  //注意事项1：
  //int max = 3 > 4 ? 2.5 : 10;//错误写法，必须同时满足左边的int类型
  //注意事项2：
  System.out.println(a > b ? a : b);//正确写法 将会打印20
  //a > b ? a : b;错误写法，编译报错
 }
}

程序流程

顺序结构

顺序结构：程序由上至下运行。

#### 选择结构 ####
1.单if语句
 

public class Demo02If{
 public static void main(String[] args){
  System.out.println("今天我准备去网吧");
  int age = 17;
  if(age >= 18){
   System.out.println("年龄满18才能进入网吧");
  }
  System.out.println("回家");
 }
}

2.if Else语句
 

public class Demo03IfElse{
 public static void main(String[] args){
  int age = 20;
  if(age >= 18){
   System.out.println("可以进入网吧");
  }else{
   System.out.println("不能进入网吧");
  }
 }
}

3.if elseif语句
 

public class Demo04IfElseExt{
 public static void main(String[] args){
  int x = 15;
  int y;
  if(x >= 3){
   y = 2*x+1;
  } else if (-1 < x && x < 3){
   y = 2*x;
  } else {
   y = 2*x-1;
  }
  System.out.println("结果是"+ y);
 }
}

4.标准的switch语句

public class Demo07Switch{
 public static void main(String[] args){
  int num = 4;
  switch(num){
   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;//不写这个break不会报错，但是强烈建议写上。
  }
 }
}

switch case注意事项:
①case后面的数值不能重复
②case后面可以是基本类型也可以是引用类型：
基本类型：byte,short,char,int
引用类型: String,enum

public class Demo08SwitchNotice{
 public static void main(String[] args){
  int num = 3;
  switch(num){
   case 2:
    System.out.println("BBB");
    break;
   case 3:
    System.out.println("AAA");
   case 1:
    System.out.println("CCC");
    break;
   default:
    System.out.println("DDD");
    break;
  }
  System.out.println("具有穿透功能的switch");
 }
}
循环结构

1.for循环

/*
循环结构：
for循环
for(初始化语句①;条件判断②；步进语句④){
 循环体③
}
*/
public class Demo09For{
 public static void main(String[] args){
  for(int i=1;i<=100;i++){
   System.out.println("我错了！请原谅我把！"+i);
  }
 }
}

2.while循环

/*
while循环：
标准格式：
while(条件判断){
 循环体
}
扩展格式：
初始化语句；
while(条件判断){
 循环体；
 步进语句；
}
*/
public class Demo10While{
 public static void main(String[] args){
  int i = 1;
  while(i<=10){
   System.out.println("我错了！"+ i );
   i++;
  }
 }
}

3.do-while循环

/*
doWhile循环
  do{
   循环体
   步进语句
  }while（条件判断）
  dowhile循环一上来就先执行一次do里面的内容，再进行条件判断是否继续循环
*/
public class Demo11DoWhile{
 public static void main(String[] args){
  int i = 1;
  do{
   System.out.println("起来吧，原谅你了");
   i++;
  }while(i <= 10);
 }
}

4.条件控制语句
break：
①在switch语句中使用，一旦执行，整个switch将被打断
②在循环中使用，一旦执行，整个循环被打断

public class Demo13Break{
 public static void main(String[] args){
  for(int i=1;i<=10;i++){
   if(i==4){
    break;
   }
   System.out.println("hello"+i);
  }
 }
}

continue：
在循环中使用，一旦执行，表示跳出当次循环，继续下一次循环

public class Demo14Continue{
 public static void main(String[] args){
  for(int i = 1;i <= 10;i++){
   if(i == 4){
    continue;
   }
   System.out.println(i+"层到了");
  }   
 }

break和continue的区别：
break是打断，终止整个循环结构，执行break后将不再执行任何循环体内容。
continue是跳出当次循环，继续下一次循环，执行continue后，循环还可以继续。
5.死循环

public class Demo15DeadLoop{
 public static void main(String[] args){
  while(true){
   System.out.println("I love Java!");
  }
  //System.out.println("hello");这是错误写法，循环不结束，这句话不会执行，会编译报错
 }
}

6.循环嵌套

public class Demo16LoopHourAndMinute {
 public static void main(String[] args){
  for(int hour = 0 ;hour < 24;hour++){
   for(int minute = 1;minute < 60;minute++){
    System.out.println( hour + "点" + minute + "分");
   }
  }
 }
}

方法

1.方法的定义
定义格式：
public static void 方法名称() {
方法体
}
调用格式：方法名称();
注意事项：

  1. 方法定义的先后顺序无所谓。
  2. 方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法。
  3. 方法定义之后，自己不会执行的；如果希望执行，一定要进行方法的调用。
public class Demo01Method {
    public static void main(String[] args) {
        printMethod();
    }
    public static void printMethod() {
        for (int j = 0; j < 5; j++) {
            for (int i = 0; i < 20; i++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

2.方法
方法其实就是若干语句的功能集合。

方法好比是一个工厂。
蒙牛工厂 原料：奶牛、饲料、水
产出物：奶制品
钢铁工厂 原料：铁矿石、煤炭
产出物：钢铁建材

参数（原料）：就是进入方法的数据。
返回值（产出物）：就是从方法中出来的数据。

定义方法的完整格式：
修饰符 返回值类型 方法名称(参数类型 参数名称, …) {
方法体
return 返回值;
}

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

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

定义一个两个int数字相加的方法。三要素：
返回值类型：int
方法名称：sum
参数列表：int a, int b

方法的三种调用格式。

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

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

public class Demo02MethodDefine {
    public static void main(String[] args) {
        // 单独调用
        sum(10, 20);
        System.out.println("===========");
        // 打印调用
        System.out.println(sum(10, 20)); // 30
        System.out.println("===========");
        // 赋值调用
        int number = sum(15, 25);
        number += 100;
        System.out.println("变量的值：" + number); // 140
    }
    public static int sum(int a, int b) {
        System.out.println("方法执行啦！");
        int result = a + b;
        return result;
    }
}

3.方法的参数
有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
例如两个数字相加，必须知道两个数字是各自多少，才能相加。

无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
例如定义一个方法，打印固定10次HelloWorld。

public class Demo03MethodParam {
    public static void main(String[] args) {
        method1(10, 20);
        System.out.println("==============");
        method2();
    }
    // 两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算
    // 有参数
    public static void method1(int a, int b) {
        int result = a * b;
        System.out.println("结果是：" + result);
    }
    // 例如打印输出固定10次文本字符串
    public static void method2() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello, World!" + i);
        }
    }
}

4.return语句

/*
题目要求：定义一个方法，用来【求出】两个数字之和。（你帮我算，算完之后把结果告诉我。）
题目变形：定义一个方法，用来【打印】两个数字之和。（你来计算，算完之后你自己负责显示结果，不用告诉我。）
注意事项：
对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
 */
public class Demo04MethodReturn {
    public static void main(String[] args) {
        // 我是main方法，我来调用你。
        // 我调用你，你来帮我计算一下，算完了之后，把结果告诉我的num变量
        int num = getSum(10, 20);
        System.out.println("返回值是：" + num);
        System.out.println("==============");
        printSum(100, 200);
        System.out.println("==============");
        System.out.println(getSum(2, 3)); // 正确写法
        getSum(3, 5); // 正确写法，但是返回值没有用到
        System.out.println("==============");
        // 对于void没有返回值的方法，只能单独，不能打印或者赋值
//        System.out.println(printSum(2, 3)); // 错误写法！
//        System.out.println(void);
//        int num2 = printSum(10, 20); // 错误写法！
//        int num3 = void;
//        void num4 = void;
    }
    // 我是一个方法，我负责两个数字相加。
    // 我有返回值int，谁调用我，我就把计算结果告诉谁
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }
    // 我是一个方法，我负责两个数字相加。
    // 我没有返回值，不会把结果告诉任何人，而是我自己进行打印输出。
    public static void printSum(int a, int b) {
        int result = a + b;
        System.out.println("结果是：" + result);
    }
}

5.使用方法时注意事项

  1. 方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
  2. 方法定义的前后顺序无所谓。
  3. 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
  4. 如果方法有返回值，那么必须写上“return 返回值;”，不能没有。
  5. return后面的返回值数据，必须和方法的返回值类型，对应起来。
  6. 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
  7. 对于void方法当中最后一行的return可以省略不写。
  8. 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
public class Demo04MethodNotice {
    public static int method1() {
        return 10;
    }
    public static void method2() {
//        return 10; // 错误的写法！方法没有返回值，return后面就不能写返回值。
        return; // 没有返回值，只是结束方法的执行而已。
    }
    public static void method3() {
        System.out.println("AAA");
        System.out.println("BBB");
//        return; // 最后一行的return可以省略不写。
    }
    public static int getMax(int a, int b) {
        /*int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;*/
        if (a > b) {
            return a;
        } else {
            return b;
        }
    }
}
方法的重载

什么是方法的重载？
多个方法的名称一样，但是数据列表不一样。

方法的重载和下列因素有关：
1.和参数个数有关。
2.和多种参数的顺序有关。
3.和参数类型有关。

方法的重载和下列因数无关：
1.和参数的名称无关。
2.和返回值类型无关。

public class Demo01MethodOverload {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
    }
    public static  int sum(int a,int b){
        return a + b;
    }
    //与参数的名称无关
//    public static int sum(int x , int y){
//        return x + y;
//    }
    //与返回值类型无关
//    public static double sum(double a , double b){
//        return a + b;
//    }
    //与参数类型有关
    public static int sum(double a ,double b){
        return (int)(a + b);
    }
    //与多个不同类型参数的顺序有关
    public static int sum(double a,int b){
        return (int)(a + b);
    }
    public static int sum(int a , double b){
        return (int)(a + b);
    }
    public static int sum(int a,int b,int c){
        return a + b + c;
    }
    public static int sum(int a,int b,int c,int d){
        return a + b + c + d;
    }
}

数组

什么是数组？
数组是一个容器，用来存储同一类型的数据。

数组的特点：
1.数组是一种引用类型数据。
2.数组中的数据是属于同一种类型。
3.数组的长度不可改变。

定义一个数组有两种常见的方式：
1.动态初始化数组(指定长度):
数据类型[] 数组名称 = new 数据类型[数组长度];

public class Demo01Array {
    public static void main(String[] args) {
        //创建一个长度为10的int类型数组
        int[] arr1 = new int[10];
        //创建一个长度为20的double类型数组
        double[] arr2 = new double[20];
        //创建一个长度为5的String类型数组
        String[] arr3 = new String[5];
    }
}

2.静态初始化数组(指定内容):
数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，…};

public class Demo02Array {
    public static void main(String[] args) {
        //创建一个数组，是int类型数据，里面装 5,10,15
        int[] arr1 = new int[]{ 5 , 10 , 15};
        //创建一个数组，里面装String类型数据，里面装"Hello" ,"World" ,"Java"
        String[] arr2 = new String[]{"Hello" , "World" , "Java"};
    }
}

静态初始化数组的省略格式：
数据类型[] 数组名称 = {元素1，元素2，…};

public class Demo03Array {
    public static void main(String[] args) {
        //省略格式创建一个给int数组，使用省略格式，里面是5,6,7
        int[] arr1 = {5,6,7};
        //静态初始化的标准格式可以拆分为两个步骤
        int[] arr2;
        arr2 = new int[]{5,6,7};
        //动态初始化也可以拆分为两个步骤
        int[] arr3;
        arr3 = new int[10];
        //静态初始化一旦使用省略格式，不能再拆分为两个步骤
//        int[] arr4;
//        arr4 = {5,6,7};//编译报错，这种格式不被允许
    }
}

Java中内存划分为5个部分：
1.栈(Stack):存储局部变量，方法的运行在栈中。
2.堆(Heap):凡是new出来的东西，都在堆中。
3.方法区：存储.class文件中的信息，包含方法信息。
4.本地方法栈：和操作系统有关。
5.寄存器：和CPU有关。

Java中数组的内存图：
1.一个数组的内存图：

public class Demo01ArrayOne {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        arr1[1] = 10;
        arr1[2] = 20;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }
}

 

2.两个数组的内存图：

public class Demo02ArrayTwo {
    public static void main(String[] args) {
        int[] arrA = new int[3];
        System.out.println(arrA[0]);
        System.out.println(arrA[1]);
        System.out.println(arrA[2]);
        arrA[1] = 10;
        arrA[2] = 20;
        System.out.println(arrA[0]);
        System.out.println(arrA[1]);
        System.out.println(arrA[2]);
        System.out.println("==================");
        int[] arrB = new int[3];
        System.out.println(arrB[0]);
        System.out.println(arrB[1]);
        System.out.println(arrB[2]);
        arrB[1] = 10;
        arrB[2] = 20;
        System.out.println(arrB[0]);
        System.out.println(arrB[1]);
        System.out.println(arrB[2]);
    }
}

 
3.两个引用指向同一个数组的内存图：

public class Demo03ArraySame {
    public static void main(String[] args) {
        int[] arrA = new int[3];
        System.out.println(arrA[0]);//0
        System.out.println(arrA[1]);//0
        System.out.println(arrA[2]);//0
        arrA[1] = 10;
        arrA[2] = 20;
        System.out.println(arrA[0]);//0
        System.out.println(arrA[1]);//10
        System.out.println(arrA[2]);//20
        System.out.println("==============");
        int[] arrB = arrA;
        System.out.println(arrB[0]);//0
        System.out.println(arrB[1]);//10
        System.out.println(arrB[2]);//20
        arrB[1] = 100;
        arrB[2] = 200;
        System.out.println(arrB[0]);//0
        System.out.println(arrB[1]);//100
        System.out.println(arrB[2]);//200
        System.out.println("==============");
    }
}

 

数组的两种常见问题：
1.数组索引越界异常：访问数组元素时，索引编号不存在，那么将会发生数据索引越界异常。ArrayIdexOutOfBoundsException
原因：索引值不正确。
解决办法：修改索引值。

public class Demo01ArrayIndexOutOfBoundsException {
    public static void main(String[] args) {
        int[] arr = {15, 25, 35};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //错误写法，会引发数组索引越界异常
        System.out.println(arr[3]);
    }
}

2.空指针异常：如果没有对数组进行初始化，访问元素的时候，会产生空指针异常。NullPointerException
原因：没有对数组进行初始化，数组是null值。
解决办法：对数组进行初始化。

public class Demo02NullPointerException {
    public static void main(String[] args) {
        int[] arr = null;
        //arr = new int[3];
        System.out.println(arr[0]);
    }
}

数组的长度：
获取数组的长度通过其length属性，即可获得。
int length = arr.length;
注意事项：
数组一旦创建，其长度是不可变的。

public class Demo03ArrayLength {
    public static void main(String[] args) {
        //创建一个长度为3的数组
        int[] arr = new int[3];
        System.out.println(arr.length);
        //这里并不是数组的长度由3变成5，而是又创建了一个
        // 长度为5的数组，变量arr的地址值发生了改变。
        arr = new int[5];
        System.out.println(arr.length);
    }
}

遍历数组：对数组中每一个元素进行逐个处理。

public class Demo04Array {
    public static void main(String[] args) {
        int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

练习：
1.求出数组中的最大值：

public class Demo05ArrayMax {
    public static void main(String[] args) {
        int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println("最大值是:"+ max );
    }
}

2.求出数组中的最小值：

public class Demo06ArrayMin {
    public static void main(String[] args) {
        int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]<min){
                min = arr[i];
            }
        }
        System.out.println("最小值是:" + min );
    }
}

3.数组的反转：

/*
* 数组的反转：
* 本来的样子：[1,2,3,4]
* 反转的样子:[4,3,2,1]
* 不能使用新的数组
*
* 思路：
* 1.数组的反转是两个对称位置的数据交换
* 2.需要两个索引，min和max
* 3.需要一个临时变量
* 4.条件判断，当min小于max时才交换，否则不交换
* */
public class Demo07ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
        //遍历原来的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        //反转
        for (int min=0,max = arr.length-1; min < max ; min++ , max-- ){
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }
        //遍历新的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

数组也可以作为方法的参数：
当调用方法的时候，向小括号传参，事实上传递的是数组在堆内存中的地址值。
数组也可以作为方法的返回值：
其实返回的也是数组在堆内存中的地址值。

public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        myPrint(arr);
        int[] result = sumAndAvg(arr);
        System.out.println(result);
        myPrint(result);
    }
    public static void myPrint(int[] arr){
        //事实上传递的是地址值
        System.out.println(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static int[] sumAndAvg(int[] arr){
        int[] arr1 = null;
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        int avg = sum / arr.length;
        arr1 = new int[]{sum , avg};
        return arr1;
    }
}
Tags：语法,JAVA,基础语法  
责任编辑：admin
  • 上一篇文章：
  • 下一篇文章： 没有了
    • 相关文章列表
    【JAVA】条件分支if和else的使用详解_if和else的用法_选择判断语…
    java开发种规范全集_java开发规范文档
    JAVA开发规范
    Java开发入门 编程入门
    Java学习6个阶段，完整Java入门教程学习步骤来了
    请文明参与讨论，禁止漫骂攻击。 昵称：（注册  登录）
    [ 查看全部 ] 网友评论
    推荐文章
    热门文章
    • 此栏目下没有热点文章
    关于我们 - 联系我们 - 广告服务 - 友情链接 - 网站地图 - 版权声明 - 在线帮助 - 文章列表
    Copyright © 2008 电子开发网 网站备案/许可证号：粤ICP备12040346号-1 站长：Rouvin林少新，Robin罗冰【合作q 357116792】
    www.dzkfw.com.cn
    返回顶部
    刷新页面
    下到页底
    晶体管查询