Day2 Java—方法+数组

Day 2—方法+数组

行业背景

产品经理（收集需求）

架构师（确定技术协议栈）

项目经理（确定项目进度）

交互/UI（设计界面）

前端工程师

后端工程师（Java，Python，PHP，Go）

测试工程师（白盒/黑盒）

运维

数据类型转换

byte b=10;
short s=20;
long l=10000000000L;  //为了和int区分
float f=10.3f;        //加f是为了和double区分
char c='a';
boolean b1=true;

• 小转大（自动）
• 大转小（强制）

强制转换：

public class Demo3{
    public static void main(String[] args){
        double b=3.14；
		int i=int(b);
        System.out.println(i);
    }
}
//结果：3


//面试题
short s=1，s=s+1;   //代码有问题，改代码
//改错：
short s=1;
short b=(short)(s+1);    //int转成short（大转小）

操作符：++，–

a=1；b=a++；//先赋值，再加1，b=1，a=2
a=1；b=++a；//先加1，再赋值，a=2，b=2
a=2000；b=a--；//先赋值，再减1，b=2000，a=1999
a=2000；b=--a；//先减1，再赋值，a=1999，b=1999
    
public class Demo2 {
    public static void main(String[] args){
        int a=100;
        int m=a++ + ++a - a++ + a;
        //a=101,a++=100
        //a=102,++a=102
        //a=103,a++=102
        //a=103
        //100+102-102+103=203
        System.out.println(m);
    }
}

+、-、*、/

public class OperatorDemo{
    pulic static void main(String[] args){
        
        System.out.println(5/4);    //1
        System.out.println(5.0/4);  //1.25
        System.out.println(5/4.0);  //1.25
    }
}

拼接操作

public class OperatorDemo{
    public static void main(String[] args){
        int a=10;
        char c='a';                //ASCII码值97
        System.out.println(a+c);   //107
        
        System.out.println("hello"+"world");    //helloworld
        System.out.println("hello"+10);         //hello10
        System.out.println("hello"+10+20);      //hello1020
        System.out.println(10+20+"hello");      //30hello
        
        int m=5;
        int n=m++;    //n=5,m=6
        
        System.out.println("m:"+m);    //m:6
        System.out.println("n:"+n);    //n:5
    }
}

键盘录入数据

• 扫描器，通过Scanner类扫描用户在控制台输入的数据

  import java.util.Scanner;     //导入Scanner包
  
  public class ScannerDemo{
      public static void main(String[] args){
          //创建键盘录入对象
          Scanner sc= new Scanner(System.in);
           
          //给出提示
          System.out.print("请输入一个整数：");   //print不换行
          
          //接收数据
          int i=sc.nextInt();
          System.out.println("i:"+i);          //println换行
          
          //给提示
          System.out.print("请输入字符串：");
          String c=sc.next();
          System.out.println("字符串为："+c);            
  	}
  }
  

流程控制语句

• 分类
  • 选择结构
  • 顺序结构
  • 循环结构

选择结构

if 三种

if
if else
if   else if``````else

switch

switch(表达式){
    case 值1：
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ````
    default:       //所有case都不满足时，就执行该处的内容。
        语句体n+1;
        break;     //可有可无
}

循环结构

for

/*   九九乘法表    */
public class ForDemo{
    public static void main(String[] args){
        for(int i=1;i<10;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"x"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

do```while

public class DpWhile{
    public static void main(String[] args){
        int count=1;
        boolean isOK=false;
        do{
            System.out.println("正在进行第"+count+"次学习");
            if(count>=100){
                isOK=true;
            }
            count++;
        }while(!isOK);
        System.out.println("学废了");
    }
}

Random类

import java.util.Random;
public class Random{         //随机输出0-4中的数，输出5次
    public static void main(String[] args){
        Random r=new Random();
        for(int i=1;i<=5;i++){
            int number=r.nextInt(5);
            System.out.println("number:"+number);
        }
    }
}

总结—实战演练

猜数字游戏

//猜数字游戏
import java.util.Random;      //引入随机生成数类库
import java.util.Scanner;     //引入Scanner扫描类库 

public class Demo1{
    public static void main(String[] args){
        Random r=new Random();                //随机生成一个数
        int number=r.nextInt(4);              //生成数范围是0-3,并把随机生成的数赋值给number
        Scanner s=new Scanner(System.in);     //创建键盘录入对象s
        int i=3;                              //3次猜词机会
        lable_class:                          //
        while(true){
            if(i<=0){
                break lable_class;            //机会少于0次，结束游戏
            }
            i--;                              //执行一次，机会少一次
            System.out.print("请输入一个数：");
            int a=s.nextInt();                //接收键盘输入
            if(a<number&&a>=0){
                System.out.println("偏小，还剩下"+i+"次机会");
            }
            else if(a>number&&a<4){
                System.out.println("偏大，还剩下"+i+"次机会");
            }
            else if(a==number){
                System.out.println("猜对了");
                break;                        //猜对了，结束游戏
            }
            else{                             //输入的数超出随机生成的范围
                System.out.println("输入错误，还有"+i+"次机会");
            }
        }
    }
}

控制台登陆

/*   控制台登录，可输入3次    */
/*  比较String不能使用“==”，要用类方法.equals   因为“==”是比较地址，不是String的值    */
import java.util.Scanner;
public class Login {

    public static void main(String[] args){
    Scanner userName=new Scanner(System.in);
    Scanner passWord=new Scanner(System.in);

    int i=3;
    while(i>0){
        i--;
        System.out.println("请输入用户名：");
        String uN=userName.next();
        System.out.println("请输入密码：");
        String pW=passWord.next();
        if(!uN.equals("zj")&&pW.equals("123")){
            System.out.println("用户名错误！您还有"+i+"次机会");
        }
        else if(uN.equals("zj")&&!pW.equals("123")){
            System.out.println("密码错误！您还有"+i+"次机会");
        }
        else if(!uN.equals("zj")&&!pW.equals("123")){
            System.out.println("用户名&密码错误！您还有"+i+"次机会");
        }
        else{
            System.out.println(uN+pW);
            System.out.println("登陆成功！");
            break;
        }
    }
    
    }
}

方法

• 完成特定功能的代码块
• 当一段代码被反复使用，可以把它提取成方法

方法格式说明

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2```){
    函数体;
    return 返回值;
}

• 修饰符：public static
• 返回值类型：结果的数据类型
• 方法名：方法的名称==（小驼峰）==
• 参数列表：执行该方法需要的条件
  • 参数类型：基本/引用类型
  • 参数名：即变量名

//static和参数列表可以不写
public class SumDemo{
    public static void main(String[] args){
        System.out.println(sum(3,5));       //调用方法sum
    }
    public static int sum(int a,int b){     //方法sum
        int c=a+b;
        return c;
    }
}

方法重载

• 同一个类中有多个方法，方法名相同，参数列表不同，称为方法重载，与返回值类型与修饰符无关

/*  
    比较两个int类型的数是否相等
    比较两个double类型的数是否相等
*/
public class Compare{
    public static void main(String[] args){
        int a=3;
        int b=5;
        
        System.out.println(compare(a,b));
        
        double c=3.14;
        double d=4.13;
        System.out.println(compare(c,d));
    }
    
    public static boolean compare(int a,int b){
        System.out.println("判断两个int类型的数是否相等：");
        return a==b;
    }
    public static boolean compare(double a,double b){
        System.out.println("判断两个double类型的数是否相等：");
        return a==b;
    }
}

课堂练习

//最好把Scanner操作写在main函数里

/*    Practice.java    */
import java.util.Scanner;
public class Sum {

    public int large(){              //方法——返回键盘输入的两个数最大值
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入两个整数：");
        int a=sc.nextInt();
        int b=sc.nextInt();
        return(a>b?a:b);
    }
    public boolean compare(){        //方法——判断键盘输入的两个数是否相等
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入两个整数：");
        int a=sc.nextInt();
        int b=sc.nextInt();
        return  a==b;
    }
    public int select(){               //方法——返回键盘输入的三个数中的最大值
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入三个整数：");
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        int temp=(a>b)?a:b;
        int max=(temp>c)?temp:c;
        return max;
    }
}

/*    Test.java    */
public class Test {
    public static void main(String[] args){
        Practice s1=new Practice();        //创建类的实例化
        
        //通过实例，调用类中的方法
        System.out.println(s1.large());
        System.out.println(s1.compare());
        System.out.println(s1.select());
    }
}

数组

• 数组用于存储多个数据值
• 是存储同一种数据类型(基本/引用)多个元素的容器（类也可做为数组类型）
• 一个类的整体也可以当成一个数组，如下

public class User {
    private int name;
    private String address;

    /*
    无参构造方法
     */
    public User(){}

    /*
    有参构造方法
     */
    public User(int name,String address){
        this.name=name;
        this.address=address;
    }

    public void setName(int name) {
        this.name = name;
    }
    public int getName(){
        return name;
    }
    public void setAddress(String address){
        this.address=address;
    }
    public String getAddress(){
        return address;
    }
}

import com.zj.Day3.User;

public class TestUser {
    public static void main(String[] args){
        /*
        无参构造
         */
        User u1=new User();
        u1.setName(01);
        u1.setAddress("镇江市京口区");
        User u2=new User();
        u2.setName(02);
        u2.setAddress("镇江市京口区");
       
        /*
        	因为类属于引用数据类型，所以一个类也可当作一个数组元素
        */
        User[] arr1=new User[2];    //一个类作为数组的元素类型
        arr1[0]=u1;
        arr1[1]=u2;
       
        for(int i=0;i<2;i++){
            System.out.println(arr1[i].getName()+arr1[i].getAddress());
        }

        /*
        有参构造
         */
        User u11=new User(11,"镇江");
        User u22=new User(22,"镇江");
        
        User[] arr3=new User[2];
        arr3[0]=u11;
        arr3[1]=u22;
       
        for(int i=0;i<2;i++){
            System.out.println(arr3[i].getName()+" "+arr3[i].getAddress());
        }
    }
}

数组的格式

public class Array{
    public static void main(String[] args){
        
        //格式1——创建数组对象
        int[] arr1=new int[3];
        
        //格式2——创建数组对象并初始化
        int[] arr2=new int[]{1,2,3};
        
        //格式3——创建数组对象并初始化
        int[] arr3={1,2,3};
    }
}

数组的访问

• 通过数组索引访问数组元素

/*    访问数组    */
public class Array{
    public static void main(String[] args){
        int[] arr1={1,2,3};
        System.out.println(arr1[0]);
    }
}

/*     遍历数组     */
public class Array{
    public static void main(String[] args){
        int[] arr1={1,2,3};
        for(int i=0;i<arr1.length;i++){
            System.out.println(arr1[i]);
        }
    }
}

数组初始化

• 是在内存中为数组开辟连续空间并为每个元素赋值的过程

• 动态初始化：仅指定长度，由系统给出默认值

  • 整数型：0
  • 浮点型：0.0
  • 字符型：“\u0000"（空字符）
  • 布尔型：false
  • 引用类型：null

• 静态初始化：给出初始值，由系统决定数组长度

Java程序的内存分配

• 方法区

  • 存储可运行的class文件，包含方法，静态成员，常量等

• 栈

  • 方法运行时使用的内存，”先进后出“

• 堆

  • 存储new出的数组或对象

• 本地方法栈

  • JVM在调用操作系统功能时使用，与开发无关

• 寄存器

  • CPU使用，与开发无关

• 数组类型

  • 变量arr存储的是数组在堆内存中的地址值，不是元素值，它通过内存地址引用堆内存中的数据，所以数组是引用类型

/*   一个数组，两个引用    */
public class Array{
    public static void main(String[] args){
        int[] arr1=new int[3];
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        
        int[] arr2=arr1;
        arr2[2]=4;
        System.out.println(arr1[2]);
        System.out.println(arr2[2]);
    }
}

数组操作异常

• 数组索引越界

  • Array Index out of bounds exception
  • 访问到了数组中不存在的索引时发生

• 空指针异常

  • Null Pointer Exception
  • 数组引用没有指向实体，却在操作实体中的元素时发生

数组案例

/*    求数组中最大元素    */
public class Array{
    public static void main(String[] args){
        int[] arr={238,459,465,856,365,764,576,324,657,834,456,765};
        int temp=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>temp){
                temp=arr[i];
            }
        }
        System.out.println("数组中最大的为："+temp);
    }
}

/*     8个工人工资      */
Array.java
public class Array {
  
    public double[] getArray(){            //方法——创建一个数组，并封装到方法getArray中
        double[] salary =new double[]{200.34,400.32,544.34,344.65,299.43,900.56,900.23,333.11};
        return salary;
    }

    public double large(double[] salary){      //方法——得到一个数组中的最大值
        double temp=salary[0];
        for(int i=0;i<salary.length;i++){
            if(temp<salary[i]){
                temp=salary[i];
            }
        }
        return temp;
    }

    public double average(double[] salary){     //方法——得到数组的平均值
        int sum=0;
        int av=0;
        for(int i=0;i<salary.length;i++){
            sum+=salary[i];
        }
        av=sum/salary.length;
        return av;
    }
}

Test.java
public class Test {
    public static void main(String[] args){
        Array a1=new Array();
        a1.getArray();
        for(int i=0;i<a1.getArray().length;i++){      //遍历输出数组
            System.out.println((i+1)+":"+a1.getArray()[i]);
        }
        System.out.println("large:"+a1.large(a1.getArray()));
        System.out.println("average:"+a1.average(a1.getArray()));
    }
}

temp;
}

public double average(double[] salary){     //方法——得到数组的平均值
    int sum=0;
    int av=0;
    for(int i=0;i<salary.length;i++){
        sum+=salary[i];
    }
    av=sum/salary.length;
    return av;
}

}

Test.java
public class Test {
public static void main(String[] args){
Array a1=new Array();
a1.getArray();
for(int i=0;i<a1.getArray().length;i++){ //遍历输出数组
System.out.println((i+1)+":"+a1.getArray()[i]);
}
System.out.println(“large:”+a1.large(a1.getArray()));
System.out.println(“average:”+a1.average(a1.getArray()));
}
}