AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java

2022-02-16 175
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： java

安装jdk

  1. 百度java官网找到对应的版本下载jdk

  2. 配置环境变量：

    1. 电脑高级系统设置 -> 环境变量

    2. 系统变量 -> 新建

    3. 找到系统变量中的Path -> 新建

      注意：jdk11以上的版本中没有jre文件夹，在jdk路径下打开命令提示符执行以下语句可生成jre文件夹。

      bin\jlink.exe --module-path jmods --add-modules java.desktop --output jre

    4. 完成后在命令提示符输入命令查看java版本

      java -version

      成功! :smiley:

注释

单行注释--//

public class Hello {
    public static void main(String[] args){
        // 单行注释
    }
}

多行注释--/ 注释 /

public class Hello {
    public static void main(String[] args){
        /*
        多
        行
        注
        释
        */
    }
}

文档注释--/* 文档注释 /

public class Hello {
    public static void main(String[] args) {
        /**
         * @Description Hello
         * @Author lwh
         */
    }
}
#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end
#parse("File Header.java")
/**
 * @time ${DATE} ${TIME}
 * @author LWH
 */
 
public class ${NAME} {
    public static void main(String[] args){
        
    }
}

数据类型

  • 八大基本类型
public class hello {
    public static void main(String[] args) {
        // 八大数据类型
        // 整数类型
        byte b = 20;
        short s = 30;
        int i = 40;
        long l = 50L; //Long类型一般在数字后面加L
        
        // 浮点类型
        float f = 0.1F; //float类型一般在数字后面F
        double d = 0.2;
        
        // 字符类型
        char c = 'a';

        // 布尔类型
        boolean bl = true;

        // 字符串
        String st = "你是谁"; //String 不是关键字，是一个类

    }
}
  • 引用类型：八大基本类型外的数据类型，叫做引用类型。

类型转换

低---------------------------------------------------->高

byte，short，char -> int -> long -> float -> double

  • 强制类型转换：(类型)变量名 高->低
public class demo01 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;
        
        System.out.println(i);//128
        System.out.println(b);//-128      
    }
}
  • 自动类型转换：低->高
public class demo01 {
    public static void main(String[] args) {
        int i = 128;
        double d = i;

        System.out.println(i);//128
        System.out.println(d);//128.0
    }
}

运算符

  • 算数运算符：+，-，*，/，%，++，--
  • 赋值运算符：=
  • 关系运算符：>，<，>=，<=，==，!=，instanceof
  • 逻辑运算符：&&，||，!
public class Demo03 {
    public static void main(String[] args) {
        //算数运算符
        int a = 15;
        int b = 20;
        int e = 0;
        //e++|++e -> 自增：e = e + 1
        int x = e++;//执行后自增
        int y = ++e;//执行前自增
        //-- 自减
        System.out.println(a + b);//35
        System.out.println(a - b);//-5
        System.out.println(a * b);//300
        System.out.println(a / (double) b);//0.75
        System.out.println(b % a);//m模运算(取余) 5

        System.out.println(x);//0
        System.out.println(y);//2

        //关系运算符
        int c = 25;
        int d = 30;
        System.out.println(c > d);//false
        System.out.println(c < d);//true
        System.out.println(c == d);//false
        System.out.println(c != d);//true

        //逻辑运算符
        boolean t = true;
        boolean f = false;
        System.out.println(t && f);//false 与：两个变量全为真，结果为true
        System.out.println(t || f);//true 或：两个变量其中一个为真，结果为true
        System.out.println(!(t && f));//true 非：取反
    }
}

Scanner

  • next()：

    • 1、一定要读取到有效字符后才可以结束输出。
    • 2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
    • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或结束符。
    • 4、next()不能得到带有空格的字符串。
import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收:");

        // 使用next方式接收
        String str = scanner.next();
        System.out.println("输出的内容为:"+str);

        // 凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}

结果：

使用next方式接收:
hello world
输出的内容为:hello

  • nextLine()：

    • 1、以Enter为结束符，nextLine()方法返回的是输入回车之前的所有字符串。
    • 2、可以获得空白。
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方式接收:");

        // 使用next方式接受
        String str = scanner.nextLine();
        System.out.println("输出的内容为:"+str);

        // 凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}

结果：

使用nextLine方式接收:
hello world
输出的内容为:hello world

选择结构

  • if单选择结构
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        if (s.equals("Hello")) {
            System.out.println(s);
        }

        System.out.println("End");

        scanner.close();
    }
}

结果：

请输入内容：
Hello
Hello
End
===========
请输入内容：
abc
End
  • if双选择结构
import java.util.Scanner;
public class Demo02 {
    public static void main(String[] args) {
        // 考试分数大于60及格，小于60不及格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score>=60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
        
        scanner.close();
    }
}

结果：

请输入成绩：
60
及格
===========
请输入成绩：
59
不及格
  • if多选择结构
import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        // 考试分数大于60及格，小于60不及格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score==100) {
            System.out.println("满分");
        } else if (score<100 && score>=90) {
            System.out.println("A");
        }  else if (score<90 && score>=80) {
            System.out.println("B");
        }  else if (score<80 && score>=70) {
            System.out.println("C");
        }  else if (score<70 && score>=60) {
            System.out.println("D");
        } else if (score<60 && score>=0) {
            System.out.println("不及格");
        } else {
            System.out.println("不合法成绩");
        }

        scanner.close();
    }
}

结果：

请输入成绩：
100
满分
===========
请输入成绩：
59
不及格
===========
请输入成绩：
86
B
===========
请输入成绩：
110
不合法成绩

switch多选择结构

public class Demo4 {
    public static void main(String[] args) {
        // case穿透 因此每一个case都要加一个break
        // switch 匹配一个具体的值
        char grade = 'C';

        switch (grade) {
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            case 'E':
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知");
        }
    }
}

结果：

及格

在java SE7之后switch支持String类型的匹配

public class Demo05 {
    public static void main(String[] args) {
        String name = "国栋";

        switch (name) {
            case "大碗鱼":
                System.out.println("番薯黎噶");
                break;
            case "国栋":
                System.out.println("国家栋梁之才");
                break;
            default:
                System.out.println("啥也不是");
        }
    }
}

结果：

国家栋梁之才

因为case匹配到相等的值后会执行后面所有的语句，所以要在每一个case最后加上一个break

循环结构

  • while循环
public class Demo01 {
    public static void main(String[] args) {
        // 计算1到100总和

        int i = 0;
        int sum = 0;

        while (i<100) { //i小于100时循环
            sum += i
            i++;
            System.out.println(i);
        }
    }
}

结果：

5050
  • do...while循环
public class Demo02 {
    public static void main(String[] args) {
        // 计算1到100总和

        int i = 0;
        int sum = 0;

        do {
            sum += i;
            i++;
        } while (i<=100);
        System.out.println(sum);
    }
}

结果：

5050

  • while与do...while的区别：

    • while先判断后执行；do...while先执行后判断
    • do...while总是保证循环体至少会被执行一次
public class Demo03 {
    public static void main(String[] args) {
        int a = 0;

        while (a < 0) {
            System.out.println("执行了while" + a);
            a++;
        }
        System.out.println("=====================");
        do {
            System.out.println("执行了do...while" + a);
            a++;
        } while (a < 0);
    }
}

结果：

=====================
执行了do...while0
  • for循环
public class demo02 {
    public static void main(String[] args) {
        // 计算1到100 奇数和与偶数和
        int oddSum = 0;
        int evenSum = 0;

        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                oddSum += i;
            } else {
                evenSum += i;
            }
        }

        System.out.println("奇数和：" + oddSum);
        System.out.println("偶数和：" + evenSum);
    }
}

结果：

奇数和：2500
偶数和：2550
  • 数组集合中的for循环
public class Demo05 {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50}; // 数组

        // 遍历数组的元素
        for (int x : numbers) {
            System.out.println(x);
        }
    }
}

结果：

10
20
30
40
50

break & continue

  • break：在任何循环语句的主体中，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩下的语句。
public class Demo01 {
    public static void main(String[] args) {
        int i = 0;

        while (i < 100) {
            i++;
            System.out.print(i + "\t");
            if (i == 5) {
                break;
            }
        }
    }
}

结果：

1    2    3    4    5
  • continue：在循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断。
public class Demo02 {
    public static void main(String[] args) {
        int i = 0;

        while (i < 50) {
            i++;
            if (i % 2 == 0 || i % 3 == 0 || i % 5 == 0) {
                continue;
            }
            System.out.print(i + "\t");
        }
    }
}

结果：

1    7    11    13    17    19    23    29    31    37    41    43    47    49

方法(函数)

  • 方法是解决一类问题的步骤的有序组合。
  • 方法包含于类或对象中。
  • 方法在程序中被创建，在其他地方被引用。
  • 原则：一个方法只完成1个功能，这样有利于后期扩展。
public class Demo02 {
    public static void main(String[] args) {
        int max = max(10, 10);
        System.out.println(max);
    }

    // 比大小
    public static int max(int num1, int num2) {
        int result = 0;

        if (num1 > num2) {
            result = num1;
        } else if (num2 > num1) {
            result = num2;
        } else {
            System.out.println("num1=num2");
            return 0; // return:终止方法
        }
        return result;
    }
}

结果：

num1=num2
0

方法的重载

  • 重载：在一个类中，有相同的函数名称，但形参不同的函数。

  • 方法的重载规则：

    • 方法名称必须相同。
    • 参数列表必须不同(个数不同、类型不同、参数排列顺序不同等)。
    • 方法的返回类型可以相同也可以不相同。
    • 仅仅返回类型不同不足以成为方法的重载。
public class Demo02 {
    public static void main(String[] args) {
        int max_int = max(10, 20);
        double max_double = max(10.0, 20.0);
        System.out.println(max_int);
        System.out.println(max_double);
    }

    // 比大小
    public static int max(int num1, int num2) {
        int result = 0;

        if (num1 > num2) {
            result = num1;
        } else if (num2 > num1) {
            result = num2;
        } else {
            System.out.println("num1=num2");
            return 0; // return:终止方法
        }
        return result;
    }

    public static double max(double num1, double num2) {
        double result = 0;

        if (num1 > num2) {
            result = num1;
        } else if (num2 > num1) {
            result = num2;
        } else {
            System.out.println("num1=num2");
            return 0; // return:终止方法
        }
        return result;
    }
}

结果：

20
20.0

可变参数(不定项参数)

  • 在方法声明中，指定参数类型后加一个省略号(...)。
  • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class Demo04 {
    public static void main(String[] args) {
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        //排序
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

结果：

The max value is 56.5
The max value is 3.0

递归

  • 方法自己调用自己。

  • 递归两部分：

    • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
    • 递归体：什么时候需要调用自身方法。
public class Demo06 {
    public static void main(String[] args) {
        // 阶乘
        System.out.println(f(5));
    }
    // 1! 1
    // 5! 5*4*3*2*1
    private static int f(int n) {
        if (n==1) {
            return 1;
        } else {
            return n*f(n-1);
        }
    }
}

结果：

120

数组

  • 数组是相同类型数据的有序集合。
  • 数组描述的是相同类型的若干个数据，按照一定先后次序排列组合而成。
  • 每一个数据称作为一个数组元素，每个数组元素可以通过一个下标来访问。

数组声明创建

public class Demo01 {
    public static void main(String[] args) {
        // 数组声明创建
        int[] nums = new int[10];
        // 给数组中元素赋值
        nums[0] = 1;

        System.out.println(nums[0]);
        System.out.println(nums[1]); // 没有赋值的元素以默认值输出 
    }
}

结果：

1
0
  • 数组的元素是通过索引访问的，数组的索引从0开始。
  • 获取数组长度：arrays.length
  • 初始化：
public class Demo02 {
    public static void main(String[] args) {
        // 静态初始化：创建+赋值
        int[] a = {1, 2, 3, 4, 5, 6};
        // 动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;

    }
}

  • 数组的默认初始化

    • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

  • 数组的四个基本特点：

    • 长度是确定的，一旦被创建，它的大小就是不可以改变的。
    • 元素必须是相同类型，不允许出现混合类型。
    • 元素可以使任何数据类型，包括基本类型和引用类型。
    • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组的本身就是对象，java中对象是在堆中的，因此数据无论保存原始类型还是其他对象类型，数组对象本身都是在堆中的。

数组的使用

  • for-each循环
public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

结果：

1
2
3
4
5
  • 作方法入参
public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        printArray(arrays);
    }

    // 打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

结果：

1 2 3 4 5
  • 数组作返回值
public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    // 打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

    // 翻转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

结果：

5 4 3 2 1

多维数组

  • 多维数组可以看成是数组的数组，如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
public class Demo05 {
    public static void main(String[] args) {
        // 二维数组
        // [4][2] 4行2列
        int[][] array = {{1, 2}, {2, 3}, {3, 4}};

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

结果：

1
2
2
3
3
4
  • 以上array可以看成是一个4行2列的数组。

冒泡排序

import java.util.Arrays;
public class Demo07 {
    public static void main(String[] args) {
        int[] a = {13, 5, 6, 3, 25, 7};
        System.out.println(Arrays.toString(sort(a)));
    }

    // 冒泡排序
    // 比较相邻两个元素，如果第一个比第二个大，就交换位置
    // 每一次比较，都会产生出一个最大或最小的数字
    // 下一轮则可以少一次排序
    // 依次循环，直到结束

    public static int[] sort(int[] array) {
        // 临时变量
        int temp = 0;
        // 外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            // 内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置

            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }
}

结果：

[3, 5, 6, 7, 13, 25]
文章标签：
Java
索引
游客kwnxmuhtqcmm2
目录
相关文章
兴化
|
3月前
|
Oracle Java 关系型数据库
认识Java
认识Java
兴化
21 2
BNTang
|
XML Java API
Java
Java SE
BNTang
244 0
greework
|
Java
【Java】肥胖问题
【Java】肥胖问题
greework
73 0
Insight.
|
存储 SQL 缓存
JAVA问答１７
JAVA问答１７
Insight.
84 0
auqbllxiu
|
Java
Java常见的坑(二)
你猜上述程序输出的是什么？ 是 ABC easy as 123 吗？ 你执行了输出操作，你才发现输出的是 ABC easy as [C@6e8cf4c6 ，这么一串丑陋的数字是什么鬼？ 实际上我们知道字符串与任何数值的相加都会变为字符串，上述事例也不例外， numbers输出其实实际上是调用了Object.toString()方法，让numbers转变为'[c' + '@' + 无符号的十六进制数。
auqbllxiu
87 0
Yeats_Liao
|
存储 算法 Java
一带而过-Java与生活
一带而过-Java与生活
Yeats_Liao
163 0
一带而过-Java与生活
小杨不会飞-44732
|
Java
1096 大美数（JAVA）
若正整数 N 可以整除它的 4 个不同正因数之和，则称这样的正整数为“大美数”。本题就要求你判断任一给定的正整数是否是“大美数”。
小杨不会飞-44732
154 0
1096 大美数（JAVA）
前端歌谣
|
Java
java24-if..else...if
java24-if..else...if
前端歌谣
103 0
java24-if..else...if
古城小白
java
java
古城小白
193 0
岛哥手记
|
Java API Android开发
Java 8的那些事
注：Android 支持所有 Java 7 语言功能，以及一部分 Java 8 语言功能（具体因平台版本而异）。
岛哥手记
374 0

热门文章

最新文章

  • 1
    Flutter之禅 内存优化篇
  • 2
    《Cadence 16.6电路设计与仿真从入门到精通》——2.4 Design Entry CIS原理图图形界面　
  • 3
    记一次对网络抖动经典案例的分析
  • 4
    国外成人网站xHamster大量用户信息黑市变卖，部分账号涉及英美政府官员
  • 5
    用户密码以BCrypt加密的方式来防范被破解
  • 6
    带你理清CPU，cache和存储器之间的逻辑运作
  • 7
    Git设置代理服务器
  • 8
    【DSW Gallery】PAI-DSW开通及授权
  • 9
    吐血整理：机器学习的30个基本概念，都在这里了（手绘图解）
  • 10
    MOSS站点的迁移(备份还原)
  • 1
    设计模式之 5 大创建型模式，万字长文深剖 ，近 30 张图解！
    49
  • 2
    《C++新特性：为多线程数据竞争检测与预防保驾护航》
    41
  • 3
    Kotlin - 区间与数组
    41
  • 4
    Kotlin - 参数与异常
    39
  • 5
    Kotlin - 运算符与中缀表达式
    34
  • 6
    Kotlin - 函数与Lambda表达式
    23
  • 7
    Kotlin - 分支与循环
    19
  • 8
    天气预报1天-中国气象局-地址查询版免费API接口教程
    20
  • 9
    《C++智能合约与区块链底层交互全解析：构建坚实的去中心化应用桥梁》
    19

    • 相关课程

    更多
  • Java高级编程
  • Java零基础入门
  • Java高级开发
  • Java面试疑难点解析 - Java Web开发
  • Java 虚拟机原理

    • 相关电子书

    更多
  • OpenCrypto Unchaining the Java
  • Java Your(Next)
  • Java8从入门到精通

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
    • 下一篇
    阿里云OSS设置跨域访问