标签 JAVA基础 下的文章

方法的使用

//一段具有独立功能的代码块 调用后执行
//代码块 在一对大括号的多行代码
//定义位置 在类里面  与main方法平级
//格式:
// public static void 方法名() {  

     // 方法体

// }
//提高代码的复用性
//调用:方法名()
/**
 * 自定义一个方法 打印1-100的整数
 */
public class Test {
    public static void main(String[] args) {
        printNum();
    }

    /**
     * 打印1-100的整数
     */
    public static void printNum(){
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
    }
}
// 格式(多个参数): 
// public static void 方法名 (数据类型 变量名1,数据类型 变量名2 ,…… ) {
//     … … 
// }

// 范例(多个参数): 
// public static void getMax( int number1,int number2 ) { 
//    … … 
//}

// 方法定义时,参数中的数据类型与变量名都不能缺少,缺少任意一个程序将报错
// 方法定义时,多个参数之间使用逗号(,)分隔
 //形参:全称形式参数,是指在定义方法时,所声明的参数
 //实参:全称实际参数,调用方法时,实际传入的参数
//方法调用时,形参和实参的数量和类型必须相匹配,否则将出现编译错误
//设计一个方法(print) 用于打印 n 到 m 之间所有的奇数
//需求:设计一个方法(getMax) 这个方法可以打印 任意 3个整数中的最大数
//需求:设计一个方法(printArrMax) 这个方法可以打印 一个int数组中的最大值
//需求:设计一个方法(printArrSum) 这个方法可以打印 一个int数组中各个元素的和
public static void main(String[] args) {
        print(10,30);
        getMax(10,30,20);
        int [] arr={20,30,40};
        printArrMax(arr);
        printArrSum(arr);
    }

    /**
     * 打印 n-m之间的所有奇数
     * @param n 任意数
     * @param m 任意数
     */
    public static void print(int n,int m){
        int temp;
        if (m<n){
            temp=m;
            m=n;
            n=temp;
        }
        for (int i=n;i<=m;i++){
            if (i%2==1){
                System.out.print(i);
            }
        }
    }

    /**
     * 打印任意三个整数最大值
     * @param a 任意数
     * @param b 任意数
     * @param c 任意数
     */
    public static void getMax(int a,int b,int c){
        int temp=a>b?a:b;
        temp=temp>c?temp:c;
        System.out.println("最大值:"+temp);
    }

    /**
     * 打印 数组中最大值
     * @param arr 数组
     */
    public static void printArrMax(int[] arr){
        int temp=0;
        for (int i = 0; i < arr.length; i++) {
            if (temp<=arr[i]){
                temp= arr[i];
            }
        }
    }

    /**
     * 打印个数组中各个元素的和
     * @param arr 数组
     */
    public static void printArrSum(int[] arr){
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum=sum+arr[i];
        }
    }
//定义一个方法 把任意字符数组拼接成一个字符串
/**
* 将字符数组拼接成一个字符串
* @param c 拼接的字符数组
*/
public static void toStrings(char[] c){
   String s="";
   for (int i = 0; i < c.length; i++) {
       s=s+c[i];
   }
   System.out.println(s);
}
//定义:
// 返回值 :就这件事情做完之后的结果
// 返回值类型: 这件事情做完后的结果的数据类型
// 方法名:这件事情的名字
// 参数:做这件事情需要的东西
// 参数类型  : 参数的数据类型  
// 参数名:就是给参数取的一个名字

//格式:
// public static  返回值类型  方法名(参数类型 参数名,参数类型2 参数名2,.....){
//     方法体;
//     return 返回值;
// }
// 例如:
// public static int getMax(int a,int b){
//    int max = a>b?a:b;
//    return max;
// }
//1.返回一个值
//2.终止方法的运行
//3.void的方法也可以写return,后面什么也不加
//4.return后面不能直接写代码
//5.switch中也可以搭配return,且具有break的作用
//6.一个方法呢可以有多个return,但是必须处在不同的作用域里面
//定义一个方法
//该方法可以给水果称重算钱
//方法名weight()
//第二个方法
//该方法可以转账 付钱
//在方法里面就写一条输出语句
//本次转账多少钱
public static void main(String[] args) {
    pay(weight(10.0,1.2));
}
/**
* 称重算钱
* @param weight 重量
* @param money 钱
* @return
*/
public static double weight(double weight,double money){
    return weight*money;
}
/***
* 转账
* @param money 需要转账的金额
*/
public static void pay(double money){
  System.out.println("本场转账"+money);
}
// 1.返回值
// 2.方法名
// 3.参数列表
//(第二要素+第三要素)(方法名+参数列表)
//同一个类中,方法名相同,参数列表不同的方法叫重载
//参数个数不同
//参数类型不同
//参数的多类型顺序不同

数组Array

一个可以存很多数据的容器

定义:

1.类型[] 变量名;
规范`写法`
例如 int[] array;
2.数据类型 变量名[] 注意:(不要使用)
例如 int array[];
//动态指定长度
//推荐使用
int[] ageArray=new int[4];
//数组索引
//0 1 2 3 4 5
//索引范围 0-(数组的长度-1)
int[] ageArray=new int[4];
//设置数组索引为0的值改为18
ageArray[0]=18;

String[] nameArray=new String[4];
nameArray[0]="张三";
nameArrayp[1]="李四";
//获取数组索引为1的内容
System.out.prinln(nameArray[0]);
//遍历修改数组内容
for(int i=0;i<ageArray.length;i++){
 ageArray[i]=10;
}
//遍历查询数组内容
for(int i=0;i<ageArray.length;i++){
     System.out.prin(ageArray[i])
}
//定义一个长度为5的数组
//使用键盘录入五个明星的名字
//再写一个遍历输出你录入的名字 在一行
import java.util.Scanner;
public class Test1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String[] names=new String[5];
        System.out.println("请输入五个明星名字");
        for (int i = 0; i < names.length; i++) {
            names[i]= sc.next();
        }
        System.out.print("你输入的五个明星名字是:");
        for (int i = 0; i < names.length; i++) {
            System.out.print(names[i]+" ");
        }
    }
}
//数组索引越界
//报错提示: ArrayIndexOutOfBoundsException
int[] arr=new int[4]
System.out.println(arr[4])  
//动态初始化数组 有默认值
//整形数组默认是0
//浮点数组默认是0.0
//布尔数组默认是false
//字符数组默认是空格
//字符串数组默认是null
//所有引入型数组默认值都是null
//1.省略格式 推荐使用
//格式 类型[] 变量名={"a","b"};
//例如:
String[] arr={"春","夏","秋","冬"};
int[] arr1={1,2,3,4,5,6};
// 2.标准格式  不推荐使用
// 格式: 数据类型[] 数组名=new 数据类型[] {元素1,元素2,元素3}
//数组求和
//对数组求平均数
int[] arr1={1,2,3,4,5,6};
int sum=0;
for (int i = 0; i < arr1.length; i++) {
    sum=sum + arr1[i];
}
System.out.println("该数组的和是"+sum);
System.out.println("该数组的平均数是"+((float)sum/(float)arr1.length));
//生成10个范围在[67-324]之间的随机数
//把生成的随机数放进数组里面
//根据数组把奇数的和求出来 并输出

Random r=new Random();
int[] arr=new int[10];
int sum=0;
for (int i = 0; i < arr.length; i++) {
    arr[i]=r.nextInt(258)+67;
    if (arr[i]%2!=0){
      sum=sum+arr[i];
    }
}
System.out.println(sum);
//生成10个范围在[67-324]之间的随机数
//把生成的随机数放进数组里面
//求数组中最小值 并输出

Random r=new Random();
int[] arr=new int[10];
int min=324;
for (int i = 0; i < arr.length; i++) {
    arr[i]=r.nextInt(258)+67;
      if (min > arr[i]){
      min=arr[i];
   }
}
System.out.println("数组中最小值:"+min);
//堆内存包含方法(内存)区
//引入数据类型主要存在堆内存中
//例如:
//int[] arr={1,2,3};
//首先在栈内存生成int[] arr;
//然后再通过栈内存的内存地址到堆内存中引入(寻址)


//栈内存是内存区内最小的
//基本数据类型存在栈内存中
// 例如:
// int a=20;
// 栈内存中 int a=20;

//所有的自变量都存在都存在堆内存
//除String
//String s="你好";
//首先在栈内存生成 String s;
//然后再在堆内存的方法区生成内存(寻址) 内存地址:"你好"

//例如:
//int[] arr={1,2,3};
//int[] arr1=arr;
//将 arr的内存地址赋值arr1;
//如果arr的值变了 arr1也跟着变

循环语句

  • while 循环
  • do…while 循环
  • for 循环

while循环

while是最基本的循环,它的结构为:

while(布尔表达式){
    //循环内容
}

只要布尔表达式为 true,循环就会一直执行下去。

do…while 循环

对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。

do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

注意: 布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false。

for循环

虽然所有循环结构都可以用 while 或者 do...while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下:

for(初始化; 布尔表达式; 更新){
    //代码语句
}

关于 for 循环有以下几点说明:

  • 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
  • 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
  • 执行一次循环后,更新循环控制变量。
  • 再次检测布尔表达式。循环执行上面的过程。

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式){
    //代码句子
}

声明语句: 声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。

表达式: 表达式是要访问的数组名,或者是返回值为数组的方法。

break 关键字

break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块。

break 跳出最里层的循环,并且继续执行该循环下面的语句。

语法

break 的用法很简单,就是循环结构中的一条语句:

break;

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中,continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。

语法

continue 就是循环体中一条简单的语句:

continue;

下面是Java语言支持的赋值运算符:

操作符描述例子
=简单的赋值运算符,将右操作数的值赋给左侧操作数C = A + B将把A + B得到的值赋给C
+ =加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数C + = A等价于C = C + A
- =减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数C - = A等价于C = C - A
* =乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数C = A等价于C = C A
/ =除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数C / = A,C 与 A 同类型时等价于 C = C / A
(%)=取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数C%= A等价于C = C%A

switch case 语句

判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。

语法

switch case 语句语法格式如下:

switch(expression){ 
   case value : 
      //语句 break; 
    //可选 case value : 
       //语句 break; 
    //可选 
       //你可以有任意数量的case语句 
    default : //可选 
     //语句 
}

switch case 语句有如下规则:

  • switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串 String 类型了,同时 case 标签必须为字符串常量或字面量。
  • switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
  • case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
  • 当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
  • 当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须
  • 包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
  • switch 语句可以包含一个 default 分支,该分支一般是 switch 语句的最后一个分支(可以在任何位置,但建议在最后一个)。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

switch注意事项

  • switch case 执行时,一定会先进行匹配,匹配成功返回当前 case 的值,再根据是否有 break,判断是否继续输出,或是跳出判断。
  • 如果 case 语句块中没有 break 语句时,JVM 并不会顺序输出每一个 case 对应的返回值,而是继续匹配,匹配不成功则返回默认 case。
  • 如果 case 语句块中没有 break 语句时,匹配成功后,从当前 case 开始,后续所有 case 的值都会输出。
  • 如果当前匹配成功的 case 语句块没有 break 语句,则从当前 case 开始,后续所有 case 的值都会输出,如果后续的 case 语句块有 break 语句则会跳出判断。

Java 条件语句 - if...else

Java 中的条件语句允许程序根据条件的不同执行不同的代码块。

一个 if 语句包含一个布尔表达式和一条或多条语句。

语法

if 语句的语法如下:

if(布尔表达式)
{
    //如果布尔表达式为true将执行的语句
}

如果布尔表达式的值为 true,则执行 if 语句中的代码块,否则执行 if 语句块后面的代码。

if...else语句

if 语句后面可以跟 else 语句,当 if 语句的布尔表达式值为 false 时,else 语句块会被执行。

语法

if…else 的用法如下:

if(布尔表达式){ 
    //如果布尔表达式的值为true 
}else{ 
    //如果布尔表达式的值为false
 }

if...else if...else 语句

if 语句后面可以跟 else if…else 语句,这种语句可以检测到多种可能的情况。
使用 if,else if,else 语句的时候,需要注意下面几点:

  • if 语句至多有 1 个 else 语句,else 语句在所有的 else if 语句之后。
  • if 语句可以有若干个 else if 语句,它们必须在 else 语句之前。
  • 一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。

语法

if...else 语法格式如下:

if(布尔表达式 1){ 
    //如果布尔表达式 1的值为true执行代码 
}else if(布尔表达式 2){ 
    //如果布尔表达式 2的值为true执行代码 
}else if(布尔表达式 3){ 
    //如果布尔表达式 3的值为true执行代码 
}else { 
    //如果以上布尔表达式都不为true执行代码 
}

嵌套的 if…else 语句

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

语法

嵌套的 if…else 语法格式如下:

if(布尔表达式 1){ 
    ////如果布尔表达式 1的值为true执行代码 
    if(布尔表达式 2){ 
        ////如果布尔表达式 2的值为true执行代码 
     } 
}

你可以像 if 语句一样嵌套 else if...else。

条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x =(expression)? value iftrue: value iffalse

下表列出了逻辑运算符的基本运算,假设布尔变量A为真,变量B为假
操作符描述例子
&&称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。(A && B)为假。
||称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。(A|&vert;)为真
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。!(A && B)为真。

短路逻辑运算符

当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了。

表格中的实例整数变量A的值为10,变量B的值为20:
运算符描述例子
==检查如果两个操作数的值是否相等,如果相等则条件为真。(A == B)为假。
!=检查如果两个操作数的值是否相等,如果值不相等则条件为真。(A != B)为真。
>检查左操作数的值是否大于右操作数的值,如果是那么条件为真。(A> B)为假。
<检查左操作数的值是否小于右操作数的值,如果是那么条件为真。(A> = B)为假
<=检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。(A <= B)为真