java 输入多个数 java输入多个数语句怎么写

DAY1 基础语法

1 键盘录入数据，使用变量接收

导包、创建对象、接收数据

import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int month = sc.nextInt;

2 if…else…if语句

if(){
} else if(){
} else if(){
} else{
}

3 switch语句

switch(month){
	case X:
	case X:
	case X:
	default:
}

4 for循环 水仙花数

需求：在控制台输出所有的“水仙花数”
①水仙花数是一个三位数
②水仙花数的个位、十位、百位数字立方和等于原数

分析：（以371为例）
①个位数字如何求？

371 1  371%10 = 1

②百位数字如何求？

371 3  371/100 = 3

③十位数字如何求？

371 7  371/10 = 37
	   371%10 = 7
       371/10%10 = 7

注：任意数字的指定为上的数值如何求？先使用整除操作将要求的数字移动到个位上，在使用取余操作取出最后一位上的值123456789 5 先整除10000得到12345，再对10取余得到5

代码：

//在控制台输出所有的水仙花数
public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int count = 0;

		for(int i = 100; i < 1000; i++)
		{
			int a = i % 10;//个位
			int b = i / 10 % 10;//十位
			int c = i /100;//百位
			
			if(a*a*a + b*b*b + c*c*c == i) {
				count++;
				System.out.println(i);
			}
		}
		System.out.println("水仙花数共有" + count +"个");
	}
}

结果：

E:\作业\Java>javac Test.java

E:\作业\Java>java Test
153
370
371
407
水仙花数共有4个

5 while 循环

初始化语句
while(条件判断语句){
	循环体语句;
	条件控制语句;
}

6 do…while 循环

初始化语句
do{
	循环体语句;
	条件控制语句;
}while(条件判断语句)

7 循环嵌套

需求：在控制台输出一天的小时和分钟

//外循环控制小时的范围，内循环控制分钟的范围
for(int hour = 0; hour < 24; hour++)
{
	for(int min = 0; min < 60; min++)
		System.out.println(hour + "时" + min + "分");
	System.out.println("---------");
}

8 Random

作用：产生一个随机数

//导包
import java.util.Random; //要在类定义上面
//创建对象
Random r = new Random(); 
//获取随机数
int number = r.nextInt(10); //获取数据的范围：[0,10)
//输出
System.out.println("number:" + number);

9 IDEA中的内容辅助键和快捷键

快速生成main()方法：psvm，回车
快速生成输出语句：sout，回车
ctrl+alt+space空格键(内容提示，代码补全等)
单行注释ctrl+/
多行注释ctrl+shift+/
格式化 ctrl+alt+L

10数组

数组的定义格式

int[] arr;//定义了一个int类型的数组，数组名是arr（推荐）
int arr[];//定义了一个int类型变量，变量名是arr数组

数组动态初始化

初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

数据类型[] 数组名 = new 数据类型[数组长度]; 
int[] arr = new int[3];

等号左边：
int:数组的数据类型
[]:代表这是一个数组
arr:代表数组的名称
等号右边：
new:为数组开辟内存空间
int:数组的数据类型
[]:代表这是一个数组
3:代表数组的长度,元素个数

数组元素访问

数组变量访问方式
格式：数组名

数组内部保存的数据的访问方式
格式：数组名[索引]

public class array_demo {
    public static void main(String[] args) {
        int[] arr=new int[3];
        //输出数组名
        System.out.println(arr);
        //输出数组元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

结果

数组静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

数据类型 [ ] 变量名 =  new  数据类型[ ] { 数据1 , 数据2 , 数据3 , ……} ;
int [ ]      arr =  new  int[ ] { 1 , 2 , 3 } ;

数据类型 [ ] 变量名 = { 数据1 , 数据2 , 数据3 , ……} ;
int [ ]      arr = { 1 , 2 , 3 } ;

数组操作两个常见小问题

索引越界

访问量数组中不存在的索引对应的元素，造成索引越界问题

int[] arr=new int[3];
System.out.println(arr[3]);//索引越界

程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。

空指针异常

访问的数组已经不再指向堆内存的数据，造成空指针异常
null：空值，引用数据类型的默认值，表示不指向任何有效对象

int[] arr=new int[3];
System.out.println(arr[2]);
arr = null;//把null赋值给数组
System.out.println(arr[2]);//找不到了

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时
候会抛出 NullPointerException 空指针异常。

两个操作

遍历

//定义数组
int[] arr = {11, 22, 33, 44, 55};
// 使用通用的遍历格式
for(int x=0; x<arr.length; x++)
{
   	System.out.println(arr[x]);
}

取最大值

//定义数组
int[] arr = {12, 45, 98, 73, 60};
 //定义一个变量，用于保存最大值
 // 取数组中第一个数据作为变量的初始值
 int max = arr[0];
 //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
 for (int x = 1; x < arr.length; x++) {
     if (arr[x] > max) {
         max = arr[x];
     }
 }//循环结束后打印变量的值
 System.out.println("max:" + max);

11 内存分配

栈内存和堆内存

12 方法

带参数方法定义和调用

//常量值的调用
        isEvenNumber(10);//10为实参

        //变量的调用
        int number = 10;
        isEvenNumber(number);//number为实参
    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
    public static void isEvenNumber(int number) {//这里的number为形参
        if(number%2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }

实参和形参

实参：方法调用中的参数
形参：方法定义中的参数

带返回值的方法定义和调用

定义

public static 数据类型 方法名 ( 参数 ) {
	 return 数据 ; 
}
public static boolean isEvenNumber( int number ) {
	 return true ; 
}
 public static int getMax( int a, int b ) {
  	return 100 ; 
}

• 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

调用

方法名 ( 参数 ) ; 数据类型 变量名 = 方法名 ( 参数 ) ; 
isEvenNumber ( 5 ) ; 
boolean flag = isEvenNumber ( 5 );

• 方法的返回值通常会使用变量接收，否则该返回值将无意义

方法的注意事项

• 方法不能嵌套定义
• void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

• 多个方法在同一个类中
• 多个方法具有相同的方法名
• 多个方法的参数不相同，类型不同或者数量不同
  注意：
• 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
• 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

正确范例

//返回值不同（无关）
//参数类型不同，是重载
public class MethodDemo {
    public static void fn(int a) {
        //方法体
    }
    public static int fn(double a) {
        //方法体
    }
}

//参数个数不同，是重载
public class MethodDemo {
    public static float fn(int a) { 
        //方法体
    }
    public static int fn(int a, int b) { 
        //方法体
    }
}

错误范例

/*错误原因：重载与返回值无关*/
public class MethodDemo {
    public static void fn(int a) {
    //方法体
    }
    public static int fn(int a) {
    //方法体
    }
}

/*错误原因：这是两个类的两个fn方法*/
public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
}
public class MethodDemo02 {
    public static int fn(double a) {
        //方法体
    }
}

方法重载练习

需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
思路：
①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
③定义所有的重载方法，两个byte类型与两个short类型参数
④完成方法的调用，测试运行结果

代码：

public class method_demo {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

方法参数传递基本类型

public class ArgsDemo01 { 
	public static void main(String[] args) { 
		int number = 100; 
		System.out.println("调用change方法前：" + number); 
		change(number); 
		System.out.println("调用change方法后：" + number); 
	}
	public static void change(int number) { 
		number = 200; 
	} 
}

• 结论：
  基本数据类型的参数，形式参数的改变，不影响实际参数
• 结论依据：
  每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

方法参数传递引用类型

public class ArgsDemo02 { 
	public static void main(String[] args) { 
		int[] arr = {10, 20, 30}; 
		System.out.println("调用change方法前：" + arr[1]); 
		change(arr); 
		System.out.println("调用change方法后：" + arr[1]); 
	}
	public static void change(int[] arr) { 
		arr[1] = 200; 
	}
 }

• 结论：
  对于引用类型的参数，形式参数的改变，影响实际参数的值
• 结论依据：
  引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

数组最大值

public class method_demo {
    public static void main(String[] args) {
        int[] arr = {11, 45, 23, 89, 34};
        int arr_max = get_arr_max(arr);
        System.out.println("arr_max:" + arr_max);
    }

    public static int get_arr_max(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
}

13 应用

逢七过

不死神兔

百钱百鸡

数组元素求和

public class arr_sum {
    public static void main(String[] args) {
        int[] arr = {68, 27,95,88,171,996,51,210};
        int num = sum(arr);
        System.out.println(num);
    }

    public static int sum(int[] arr) {
        int s = 0;
        for(int i = 0; i < arr.length; i++){
            if(arr[i]%2 == 0 && arr[i]%10 != 7 && arr[i]/10%10 !=7){
                s += arr[i];
            }
        }
        return s;
    }
}

DAY 2 面向对象

1 面向对象基础

• 类的定义步骤：
  ①定义类
  ②编写类的成员变量
  ③编写类的成员方法
• 创建对象的格式：
  类名 对象名 = new 类名();
• 调用成员的格式：
  对象名.成员变量
  对象名.成员方法();

package study01;

//定义手机类
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public static void call(){
        System.out.println("打电话");
    }
    public static void sendMessage(){
        System.out.println("发短信");
    }
}

//定义手机测试类
public class phoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();

    }
}

2 成员变量和局部变量的区别【理解】

• 类中位置不同：成员变量（类中方法外）
  局部变量（方法内部或方法声明上）
• 内存中位置不同：成员变量（堆内存）
  局部变量（栈内存）
• 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）
  局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
• 初始化值不同：成员变量（有默认初始化值）
  局部变量（没有默认初始化值，必须先定义，赋值才能使用）

3 封装

1. 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，
如果需要被其他类使用，提供相应的操作

• 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
• 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

package study02;

/* 学生类 */
class Student {
    //成员变量
    String name;
    private int age;

    //提供get方法
    public void setAge(int a) {
        if (a < 0 || a > 120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

/* 学生测试类 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        
        //调用show方法
        s.show();
        //使用get方法获取成员变量的值
        System.out.println(s.name + "," + s.getAge());
    }
}

4 this

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

• 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
• (方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量)

public void setName(String name) {
        this.name = name;// 上面的成员变量 = 此方法中的局部变量(赋值)
    }

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

5 构造方法

作用：

创建对象 Student stu = new Student();

格式：

public class 类名{
		修饰符 类名( 参数 ) {
		}
}

功能：主要是完成对象数据的初始化
示例代码：

class Student {
    private String name;
    private int age;
    
    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
    
}/* 测试类 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

• 构造方法的创建
  如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法
• 构造方法的重载
  如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
  推荐的使用方式。无论是否使用，都手工书写无参数构造方法
• 重要功能！
  可以使用带参构造，为成员变量进行初始化

/* 学生类 */
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

/* 测试类 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();
        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();
        //public Student(int age) 
        Student s3 = new Student(30);
        s3.show();
        //public Student(String name,int age)
        Student s4 = new Student("林青霞", 30);
        s4.show();
    }
}

6 标准类制作

1. 成员变量
   使用private
2. 构造方法
   提供一个无参构造方法
   提供一个带多个参数的构造方法
3. 成员方法
   提供每一个成员变量对应的setXxx()/getXxx()
   提供一个显示对象信息的show()
4. （测试类中）
   创建对象并为其成员变量赋值的两种方式
   无参构造方法创建对象后使用setXxx()赋值
   使用带参构造方法直接创建带有属性值的对象

应用

需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有
参创建的对象直接赋值，并通过show方法展示数据。
示例代码：

package study03;

class Student {
    //成员变量
    private String name;
    private int age;

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

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

    //成员方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

/*------------------------------------
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞", 30);
        s2.show();
    }
}

7常用API

API

API (Application Programming Interface) ：应用程序编程接口

帮助文档

使用帮助文档

看什么？

看是否需要导包

看是用来干嘛的

看构造方法 、成员方法

练习

package study04;

import java.util.Scanner;

/*
    Scanner:
    一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。
        用于获取键盘录入数据。（基本数据类型）
    public String nextLine():
        获取键盘录入字符串数据

 */

public class ScannerDemo {
    public static void main(String[] args) {
        //用含参（System.in）构造方法（Scanner()）创建对象
        Scanner sc = new Scanner(System.in);

        //接收数据
        System.out.println("请输入一个字符串数据：");
        /*
        Ctrl+Alt+V 只写右边sc.nextLine()，生成左边String line = 
        调用方法的时候，如果方法有明确的返回值，我们用变量接收
        可以使用快捷键完成
        */
        String line = sc.nextLine();
        
        //输出结果
        System.out.println("你输入的数据是：" + line);
    }
}

下一篇待续…