javaimport快捷键所有 java for快捷键

转载

码海舵手 2023-12-13 02:57:00

文章标签 javaimport快捷键所有 System 数据类型 java 文章分类 Java 后端开发

文章目录

快捷键+小技巧
hellowworld 基础
switch语句
for语句：
while 循环
三种循环体区别：
break语句
continue语句
random函数：用于产生随机数
数组：
方法重载：
遍历

快捷键+小技巧

单行注释：ctrl+/
多行注释：ctrl+shift +/
文档注释： /** */（手动输入）
shift+F10 运行程序
向下复制一行或选中的多行 Ctrl + D

内容辅助键：
快速生成语句：
快速生成main()方法：psvm，回车；
快速生成输出语句：sout，回车；
内容辅助键：
Ctrl+Alt+space（内容提示，代码补全等）。
导包快捷键：Alt+Enter

1.ctrl + Home:定位到一页代码的行头
2.ctrl + end :定位到一页代码的行末
3.home：定位到一行的行头
4.end：定位到一行的行末

del删除的是后面单词
shift+删除键删除一行
CTRL+删除键删除一个单词

ctrl+shift+enter，可以在本行的任意位置跳到下一行

hellowworld 基础

java特点：面向对象，健壮性，跨平台性。

package com.company;

public class Main {

    public static void main(String[] args) {
	    System.out.println("Hellow world");
//常量
	    //整数常量
        System.out.println(12);

        //小数常量
        System.out.println(12.23);

        //字符常量
        System.out.println('a');

        //布尔常量
        System.out.println(true);

//变量：在程序的执行过程中，其值可以在一定范围内发生改变
//要求：三部分 数据类型  变量名=初始值
        //变量
        int a = 10;
        System.out.println(a);

        long b = 1000000000000L;
        System.out.println(b);

        float c = 12.34F;
        System.out.println(c);

        char ch = 'a';
        System.out.println(ch);

        boolean bb = true;
        System.out.println(bb);
    }
}

变量注意：

整数默认int类型，定义long类型变量的时候，建议加L或l
浮点数默认double类型，定义float类型变量的时候，建议价F或f
变量未赋值，不能直接使用
变量只在他所属的范围内有效（只在他的大括号内，局部变量）

数据类型：

javaimport快捷键所有 java for快捷键_java

类型转换：

隐式转换：
byte，short，char-- int --float – double
强制转换（不建议）：
目标类型变量名 = （目标类型）（被转换的数据）

package com.company;

public class Main {

    public static void main(String[] args) {
//类型转换
    //隐性转换
    int a = 10;
    byte b = 20;
        System.out.println(a+b);


    //强制转换(不建议）
    byte e = (byte)(a+b);
        System.out.println(e);
    }
}

三元运算符：
关系表达式？表达式1：表达式2；

package com.company;

public class Main {

    public static void main(String[] args) {
    int a =10;
    int b =20;

    int c =(a>b)?a:b;
        System.out.println("c:"+c);
    }
}

Scanner 录入数据

package com.company;
//导入scanner
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
    //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

    //输出提示
        System.out.println("请输入一个整数：");

    //获取数据
        int i =sc.nextInt();

    //把获取的数据输出
        System.out.println("i："+i);

    }
}

小例子：

package com.company;


import java.util.Scanner;

/**
 * 需求：键盘录入两个数据，获取两个数的最大值
 *
 * 分析：
 * 1.看到键盘录入，想三步：导包，常见键盘录入对象，获取数据
 * 2.用if语句进行判断
 */
public class Main {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //给出提示
        System.out.println("请输入第一个整数：");
        int a = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int b = sc.nextInt();

        int max;
        if(a>b){
            max = a;
        } else{
            max = b;
        }
        System.out.println("较大的数为"+max);
    }
}

switch语句

package com.company;


import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入一个整数（1-7）");

        int day = sc.nextInt();

        switch (day){
            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;

        }
    }
}

for语句：

for（初始化语句；判断条件语句；控制条件语句）{
循环语句}

package com.company;

public class Main {
    public static void main(String[] args) {

        //for语句
        for(int x=1; x<=5; x++)
        System.out.println("hellow world");
    }
}

package com.company;

/**
 * 需求：求1-100中的偶数和
 */
public class Main {
    public static void main(String[] args) {
    //定义求和变量，初始值为0
        int sum = 0 ;
        for(int x=1;x<=100;x++){
            //判断是否是偶数
            if(x%2 == 0){
                //是偶数就累加
                sum += x;
            }
        }
    //输出变量
        System.out.println("sum="+sum);
    }
}

while 循环

package com.company;

/**
 * 需求：求1-100求和
 */
public class Main {
    public static void main(String[] args) {
    int sum = 0;
    int x=1;

    while(x<=100){
        sum +=x;
        x++;
    }
        System.out.println("sum="+sum);
    }
}

三种循环体区别：

do while 循环语句至少执行一次循环体
for和while 循环语句要先进行条件的判断，然后看知否执行循环体语句。

for 与 while 循环的区别：
for循环结束后，初始化的变量就不能被使用了
while循环结束后，初始化的变量还可以被继续被使用

推荐使用的顺序：
for ---- while - ----- do…while

package com.company;

/**
 * do while  while  for 循环的区别
 */
public class Main {
    public static void main(String[] args) {

    //do...while 循环
    int x = 3;
    do {
        System.out.println("666");
        x++;
    }while(x<3);

    //while循环
    int a = 3;
    while(a<3){
        System.out.println("666");
        a++;
    }

    //for循环
    for(int c=1;c<3;c++){
        System.out.println("666");
    }
    }
}

break语句

package com.company;

/**
 * break语句
 * 用于结束离他最近的循环
 */
public class Main {
    public static void main(String[] args) {

    for(int x=1;x<=5;x++){
        if(x ==3 ){
            break;
        }
        System.out.println("hellow");
    }
    }
}

continue语句

package com.company;

/**
 * continue语句
 * 跳出这一次的操作，进入下一次操作
 */
public class Main {
    public static void main(String[] args) {

    for(int x=1;x<=5;x++){
        if(x ==3 ){
            continue;
        }
        System.out.println("hellow"+x);
    }
    }
}

random函数：用于产生随机数

package com.company;

import java.util.Random;

/**
 * Random用于产生随机数
 */
public class Main {
    public static void main(String[] args) {

    //创建对象
        Random r = new Random();

        for(int x=1; x<=10; x++){
            //获取随机数
            int number = r.nextInt(10);
            System.out.println("number"+number);
        }
    }
}

数组：

package com.company;
/**
 * 数组：存储 同一种数据类型 的多个元素的容器
 *
 * 定义：数据类型[]  数组名；
 * eg： int[] arr;
 *
 * 数组初始化：
 * 1. 动态初始化     只给出长度 有系统给出初始值
 * 2. 静态初始化     给出初始值，由系统决定长度
 *
 * 动态初始化：
 *      数据类型[] 数组名 = new 数据类型[数组长度]
 *      获取元素的格式： 数组名[索引]
 * 静态初始化：
 *      数据类型[] 数组名 = new 数据类型[] {元素1，元素2...}
 *      简化： 数据类型[] 数组名 = {元素1，元素2...}
 */
public class Main {
    public static void main(String[] args) {
        //数据类型[] 数组名 = new 数据类型[数组长度]
        int[] arr = new int[3];

            System.out.println("arr[0]:"+arr[0]);
            System.out.println("arr[1]:"+arr[1]);
            System.out.println("arr[2]:"+arr[2]);


		//数据类型[] 数组名 = {元素1，元素2...}
        int[] arr = {1,2,3};

        System.out.println("arr:"+arr);
        System.out.println("arr[0]:"+arr[0]);
    }
}

package com.company;


/**
 * 数组常见操作
 */
public class Main {
    public static void main(String[] args) {
        //数组遍历
        int[] arr = {1,2,3,4,5};

        for(int x=0; x<arr.length; x++){
            System.out.println(arr[x]);
        }
        //获取数组最大值
        int max = arr[0];
        for(int x=1; x<arr.length;x++){
            if(arr[x] > max){
                max = arr[x];
            }
        }
        System.out.println("max:"+max);
    }
}

package com.company;


import java.util.Scanner;

/**
 * 需求：评委打分
 */
public class Main {
    public static void main(String[] args) {
    //创建一个长度为6的数组
    int[] arr = new int[6];

    //键盘录入
    Scanner sc = new Scanner(System.in);
    for(int x=0; x<arr.length;x++){
        System.out.println("请输入第"+(x+1)+"个评委给出的分数");
        int score = sc.nextInt();
        arr[x] = score;
    }

    //获取数组的最大值
    int max = arr[0];
    for(int x=1;x<arr.length;x++){
        if(int[x]>max){
            max = arr[x];
        }
    }

    //获取数组的最小值
    int min = arr[0];
    for(int x=1;x<arr.length;x++){
        if(int[x]>min){
            min = arr[x];
        }
    }

    //求出总分
    int sum = 0;
    for(int x=0; x<arr.length; x++){
        sum += arr[x];
    }

    //平均分
    int avg = (sum - max - min)/(arr.length-2);

    //输出
        System.out.println(avg);
    }
}

package com.company;


import java.util.Scanner;

/**
 * 方法：完成特定功能的代码块
 *
 * 定义格式：
 *         修饰符 返回值类型 方法名（参数类型 参数名1，从参数类型 参数名2....）
 *         方法体；
 *         return 返回值；
 *
 */
public class Main {
    public static void main(String[] args) {

        //调用方法
        //方法参数（个数和类型）
        //返回了一个int值，所以用int 类型变量进行接收
        int result = sum(10,20);
        System.out.println("result:"+result);
    }
    public static int sum (int a,int b){
        int c = a+b;
        return c;
    }

}

package com.company;


import java.util.Scanner;

/**
 *  需求： 键盘输入两个数据，返回两个数中较大的值
 *
 *
 *  命名习惯：
 *  类：
 *      每个单词的首字母都大写
*
 *   方法：
 *      一个单词 都小写
 *      多个单词 第二个单词大写
 */
public class Main {
    public static void main(String[] args) {
    //键盘录入数据
    Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数据");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据");
        int b = sc.nextInt();

        //调用方法
        int max = getMax(a,b);
        System.out.println("max:"+max);
    }

    public static int getMax(int a, int b){
    if (a>b){
        return a;
    }else{
        return b;
    }
    }
}

方法重载：

在同一个类中，出现了方法名相同的情况

注意：在调用的时候，java虚拟机会根据方法名即参数的不同来区分方法

遍历

遍历数组：

package com.company;


import java.util.Scanner;

/**
 *  需求： 遍历数组
 */
public class Main {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        printArray(arr);
    }


    public static void printArray(int[] arr){
        for(int x=0;x<arr.length;x++){
            System.out.println(arr[x]);
        }
    }
}

package com.company;


import java.util.Scanner;

/**
 *  需求： 遍历数组  取得最大值
 */
public class Main {
    public static void main(String[] args) {
        int[] arr = {11,22,89,44,55};
        getMax(arr);
    }
    public static void getMax(int[] arr){
        int max = arr[0];
        for(int x=1;x<arr.length;x++){
            if(arr[x]>max){
                max = arr[x];
            }
        }
        System.out.println("max:"+max);
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。