Java SE语法快速入门

Java简介

第一个Java程序

• 下载JDK（Java开发环境）

  • www.oracle.com

  • java

  • oracle java

  • java 8

  • windows x64

• 安装JDK

  • 直接下一步，安装时路径尽量不要包含中文

• 环境变量配置

  • CLASSPATH：指定class文件所在的目录的

  • JAVA_HOME：JDK安装的根路径

  • Path：在Path变量中加入%JAVA_HOME%\bin;

  • 在cmd中分别输入：java、javac、java -version这三组命令，都正常输出就表示配置成功

• 编写程序代码

public class HelloWorld{
    public static void main(String[] args) {        
        System.out.println("Hello World");
    }
}

• 中文乱码问题：使用记事本编辑.java文件时，在保存时可以选择文件的编码格式，用来解决使用命令javac编译出现的乱码问题。

A. 不同的国家和地区制定了不同的标准，由此产生了 GB2312、GBK、Big5、Shift_JIS 等各自的编码标准。这些使用 1 至 4 个字节来代表一个字符的各种汉字延伸编码方式，称为 ANSI 编码。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；

B.Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。C.Unicode 编码共有三种具体实现，分别为utf-8,utf-16,utf-32；

D.utf-8是Unicode编码的实现，UTF-8就是在互联网上使用最广的一种Unicode的实现方式。

• 编译源代码

执行完下面代码，目录中会出现一个HelloWorld.class文件，该文件就是编码后的字节码文件，供Java虚拟机运行。

javac HelloWorld.java

• 运行代码

java HelloWorld

3、Java程序开发流程

4、Java跨平台原理

5、JVM、JDK、JRE

JVM：Java虚拟机

JRE：Java运行环境

JDK：Java开发环境

JDK > JRE > JVM

运算符

• 运算符：指的是+-*/这类符号

• 表达式：指的变量与运算符结合在一起的就叫表达式：a + b

• 可以这样来记：但凡有值的都是表达式。

算术运算符

• +

  • 如何表达式中有字符串参与，那么结果一定是字符串

• -

• *

• /

  • 整数相除，结果一定为整数

• %

• ++

  • ++在前表示先自增，后参与运算

  • ++在后表示先参与运算，后自增

• --

• 

   给出任何一个4位数，分别打印出它的千位、百位、十位、个位？

  int a = 3474;
  System.out.println(a/1000);     //千位
  System.out.println(a/100%10);   //百位
  System.out.println(a/10%10);    //十位
  System.out.println(a%10);       //个位

 关系运算符

关系运算符表达式的结果是boolean类型

 逻辑运算符

• &逻辑与
• |逻辑或
• !非
• &&短路与
• ||短路或
• ^逻辑异或

&（与）,|(或)，^(异或)，!(非),&&(短路与),||(短路非)

&&与&的区别：&&称作短路与，也就是在运算的时候，当第一个表达式结果是false时，第二个表达式就不会执行，只有第一个表达式为true的时候，才会执行第二个表达式。&需要两个表达式都执行。

||与|的区别：||称作短路或，道理同&&与&的区别一样，在使用短路或运算时，当第一个表达式为true时，不会执行第二个表达式，其结果一定是true。当第一个表达式为false时，才会执行第二个表达式。|同样需要两个表达式都执行。

赋值运算符

 实现两数交换几种方式

  //定义两个int类型，实现两数交换
        int a = 3, b = 4;   //a=4, b=3

        //方式一：定义一个第三方临时变量
//        int c = a;
//        a = b;
//        b = c;
//        System.out.println(a);
//        System.out.println(b);

        //方式二：使用按位异或
//        a = a ^ b;  //a=7,b=4
//        b = a ^ b;  //a=7,b=3
//        a = a ^ b;  //a=3,b=4
//        System.out.println(a);
//        System.out.println(b);

        //方式三：
        a = a + b;  //a=7, b = 4
        b = a - b;  //a=7, b= 3
        a = a - b;  //a=4, b =3
        System.out.println(a);
        System.out.println(b);

 位运算符

• >> 右移运算

• << 左移运算

• ^ 按位异或

if分支语句

• 顺序结构

• 分支结构

• 循环结构

 if单分支

if (条件表达式) {
    //语句体
}

 if...else双分支

if(条件表达式){
    //语句体1
}else {
    //语句体2
}

if...else if()...else多分支

if(条件表达式){
    //语句体1
}else if(条件表达式) {

}...else{
    //语句体2
}

 进制之间的转换

 二进制转换为十进制

0b10110--->0*20+1*21+1*22+0*23+1*24=22

八进制转换为十进制

026--->6*80+2*81=22

十六进制转换为十进制

0x16---->6*160+1*161=22

十进制转换为二进制

JVM内存空间

方法区：
存储类相关的信息

栈：
存储临时变量, 局部变量

堆：
引用类型的真正数据, 对象

类加载
类加载是将字节码(class文件)中的类信息读取到JVM方法区中的过程。
类加载由类加载器完成。

方法
有些语言中也被称为“函数”/“过程”，就是一些代码

1、语法/结构：
修饰词         +         方法返回值类型         +     方法名 +     (参数列表) + {方法体}
 public static    void/int/int[]/boolean/String   main/随意    int a, int b   一些代码

2、参数:
参数也叫临时变量，需要有类型与变量名
参数列表可以为空, 也可以多个, 多个参数之间用’,'隔开

3、返回值：
有返回值的方法, 需要通过return返回结果
return表示方法结束, 没有返回值的方法, 也可以使用return

常用方法：

Scanner
int nextInt(): 获取控制台内容, 并且转换成int值返回
double nextDouble(): 获取控制台内容,并且转换成double返回
String next(): 获取控制台字符串, 并返回(遇到回车或者空格读取结束)
String nextLine(): 获取控制台一整行字符串,并返回(遇到回车结束)


System
void print(内容) -> 打印, 不换行
void println(空/内容) -> 打印完, 换行

Math
double random(): 返回一个[0,1)随机数
double pow(double d1, double d2): 返回 d1 的 d2 次幂
转义字符: \n:回车 \r:换行 \t:制表符 \:\本身

String:
char charAt(int index): 返回index索引位置对应的字符

Arrays:

String toString(数组): 将数组变成字符串格式返回

循环

思考：在控制台输出1-100

在Java中，循环有for循环、while循环、do...while循环。主要还是以for循环和while循环为主

 for循环

for循环通常应用于已知循环次数的情况下

for(int i=0; i<100; i++){
    //循环体
}
​
//执行循环1234-》234-》234...

 //1.在控制台输出1-100
//        for (int i=1; i<=100; i++){
//            System.out.println(i);
//        }

//        for (int i = 1; i <= 100; i++) {
//            System.out.println(i);
//        }

        //2.在控制台打印1-100之间所有的奇数
//        for (int i = 1; i <= 100; i+=2) {
//            System.out.println(i);
//        }

        //3.在控制台打印100-1
//        for (int i = 100; i>0; i--) {
//            System.out.println(i);
//        }

        //4.在控制台打印1-100之间3的倍数，不能使用i+=3这种形式
//        for (int i = 1; i <= 100; i++) {
//            if (i%3==0) {
//                System.out.println(i);
//            }
//        }

        //5.计算从1加到100的和
//        int sum = 0;
//        for (int i = 1; i <= 100; i++) {
//            sum+=i; //sum = sum + i;
//        }
//        System.out.println(sum);

//有一张纸，厚度为1毫米，问经过多少次折叠，可以超过珠穆朗玛峰的高度？8848.86米
//  1
//  8848860
public static void main(String[] args) {
    int i = 1;          //纸张厚度
    int j = 0;          //折叠次数
    while(i < 8848860){
        i = i << 1;     //左移
        j++;
        System.out.println("折叠"+j+"次，厚度为：" + i);
    }
    System.out.println(j);
}

/**
 * 乘法口诀表
 * 行数为9
 * 列数=1-行数
 *
 * @param args
 */
public static void main(String[] args) {

    //控制行
    for (int i = 1; i <=9 ; i++) {
        //控制列
        for (int j = 1; j <= i ; j++) {
            System.out.print(j + "*" + i + "=" + (j*i) + "\t");
        }
        System.out.println();   //换行
    }

}

/**
 * 等腰三角形
 *
 * @param args
 */
public static void main(String[] args) {
    int n = 5;

    for (int i = 0; i < n; i++) {
        //控制空格的输出
        for (int j = n - i; j > 0; j--) {
            System.out.print(" ");
        }
        //控制*号的输出
        for (int j = 0; j < 2 * (i + 1) - 1; j++) {
            System.out.print("*");
        }
        System.out.println();
    }
    for (int i = 0; i < n - 1; i++) {
        //控制空格的输出
        for (int j = 0; j < i + 2; j++) {
            System.out.print(" ");
        }
        //控制*号的输出
        for (int j = 0; j < 2 * (n - 1 - i) - 1; j++) {
            System.out.print("*");
        }
        System.out.println();

    }

    for (int i = 1; i < 8; i++) {
        System.out.println("*");
        for (int j = 0; j < 8; j++) {
            System.out.print("* ");
        }
    }
}

//1、定义一个int类型的数组，并从数组中找出最大值
public static void main(String[] args) {
    int[] arr = {3,5,6,48,4};

    int max = arr[0];

    //循环比对
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    System.out.println(max);

}

 //2、定义一个int类型的数组，将数组的内容倒过来，例如：12345，倒过来后就是54321
    
    public static void main(String[] args) {
        int[] arr = {3,5,41,6,48,4};

        for (int i = 0; i < arr.length / 2; i++) {
            //首：arr[i]
            //尾：arr[arr.length-1-i]

            arr[i] = arr[i] ^ arr[arr.length-1-i];
//            7       3           4
//            0111     0011        0100
            arr[arr.length-1-i] = arr[i] ^ arr[arr.length-1-i];
//                  3               7           4
            arr[i] = arr[i] ^ arr[arr.length-1-i];
//            7          7            3
        }
        System.out.println(Arrays.toString(arr));
    }

/**
     * 选择排序
     *
     * @param args
     */
//    public static void main(String[] args) {
//        int[] arr = {12,5564,65465,464,654,651,2};
//
//        //控制循环轮数=长度-1
//        for (int i = 0; i < arr.length - 1; i++) {
//            int n = i;  //表示本轮要交换的数的索引
//
//            //控制每轮循环的次数
//            for (int j = i+1; j < arr.length; j++) {
//                if (arr[n] > arr[j]) {
//                    n = j;
//                }
//            }
//
//            //真正交换
//            if (n!=i) {
//                arr[i] = arr[i] ^ arr[n];
//                arr[n] = arr[i] ^ arr[n];
//                arr[i] = arr[i] ^ arr[n];
//            }
//        }
//
//        System.out.println(Arrays.toString(arr));
//    }

    /**
     * 冒泡排序
     *
     * @param args
     */
//    public static void main(String[] args) {
//        int[] arr = {12,5564,65465,464,654,651,2};
//
//        //循环轮数=长度-1
//        for (int i = 0; i < arr.length - 1; i++) {
//            //控制每轮比较的次数
//            for (int j = 0; j < arr.length-1-i; j++) {
//                //如果前一个数大于后面的数，则交换
//                if (arr[j] > arr[j+1]) {
//                    arr[j] = arr[j] ^ arr[j+1];
//                    arr[j+1] = arr[j] ^ arr[j+1];
//                    arr[j] = arr[j] ^ arr[j+1];
//                }
//            }
//        }
//
//        System.out.println(Arrays.toString(arr));
//
//    }

/**
 * 25人围成1圈，依次从1开始报数，数的3的人退出圈子，下一个人继续从1开始报数，以此类推，问最后剩下的那个学生是原来的第几个学生（数组）
 *

     int[] arr = new int[3];
//
//        int m = 0;  //报的数
//        int n = 0;  //退出人数
//        while(n<arr.length-1){
//            for (int i = 0; i < arr.length; i++) {
//                if (arr[i]==0) {
//                    m++;
//                    if (m%3==0) {
//                        arr[i] = -1;
//                        n++;
//                        m=0;
//                    }
//                }
//            }
//        }

//        System.out.println(Arrays.toString(arr));
//        for (int i = 0; i < arr.length; i++) {
//            if (arr[i]==0) {
//                System.out.println(i+1);
//            }
//        }

3.2 while循环

通过应用在不知道循环次数的情况下

while(条件表达式){
    //循环体
}

3.3 嵌套循环

思考：如何在控制台打印出9*9乘法口诀表？

//控制行
for (int i = 1; i <=9 ; i++) {
    //控制列
    for (int j = 1; j <= i ; j++) {
        System.out.print(j + "*" + i + "=" + (j*i) + "\t");
    }
    System.out.println();   //换行
}

break语句：break用来结束整个循环.

continue语句：continue语句用来结束当前循环进行下一次循环

数组

 数组的定义

数组本质也是一个容器。

1. 数据类型一致

2. 长度固定

3. 内存空间连续

数组的属性——length属性

数组中的length属性用来表示数组的长度，也就是数组中的元素个数。

数组中元素的下标范围在0~length-1，一旦数组的下标超过此范围就会出现数组下标越界。因此需要警惕数组的下标越界和数组空指针异常

//方式一
数据类型[] 数组名 = new 数据类型[长度];
​
//方式二
数据类型[] 数组名2 = new 数据类型[]{值1,值2,值3,值4...};
​
//方式三
数据类型[] 数组名3 = {值1,值2,值3,值4...};

多维数组（二维数组比较常见）

对二维数组中元素的访问也是通过下标的方式，如需访问二维数组中第一个元素数组的第二个元素，arr01[0][1].

二维数组的遍历:

 

 数组的基本使用

//添加元素
num[0]=1;
num[1]=2;
​
//取索引为3的元素
System.out.println(num[3]);
​
//遍历数组
for (int i = 0; i < num.length; i++) {
    System.out.println(num[i]);
}
​
//通过Arrays工具来输出数组中的内容
System.out.println(Arrays.toString(num));

数组的应用案例

数组的基本操作——遍历，求数组中的最大值

数组的遍历实际上是利用数组的空间连续性，使用下标来访问数组中的每一个元素，通过循环数组的下标获取数组元素。

求数组的最大值：假设数组的第一个元素是最大值，把数组中的每一个元素一次和该最大值比较，如果存在比该值大的元素，则将此元素重新赋值给最大值变量。

java如何实现从一个整型数组中随机取一个数?

int[] temp = { 1, 2, 3, 4, 5, 123, 213, 123, 213, 21, 321321 };

int index = (int) (Math.random() * temp.length);// 随机数乘以数组长度，那么它的取值就在0-length之间

System.out.println(temp[index]);

lang math random只是一个方法：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

util 的Random是一个类：包含nextInt（值），nextDouble 类似的方法

                                                      不包括该值

Scanner类

    public static void main(String[] args) {
        String s,s1;
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入第一个字符串：");
        s=sc.next();
        System.out.print("请输入第二个字符串：");
        s1=sc.nextLine();
        System.out.println("输入的字符串是："+s1+" "+s);
    }
结果为

请输入第一个字符串：holle
请输入第二个字符串：输入的字符串是： holle


//    next() 方法遇见第一个有效字符（非空格，非换行符）时，开始扫描，当遇见第一个分隔符或结束符(空格或换行符)时， 结束扫描，获取扫描到的内容，即获得第一个扫描到的不含空格、换行符的单个字符串。
//}nextLine()时，则可以扫描到一行内容并作为一个字符串而被获取到。

JAVA中数组与链表有什么区别？

一、主体不同

1、数组：是有序的元素序列。将有限个类型相同的变量的集合命名。

2、链表：是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

二、组成不同

1、数组：是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。

2、链表：由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。

三、特点不同

1、数组：所有元素都具有相同类型。数组中的元素存储在一个连续性的内存块中，并通过索引来访问。

2、链表：可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

 面向对象

面向对象是一种编程思想，它基于面向过程的基础之上，把现实中的事物映射为对象，从而使用对象的关系描述事物之间的关系。万物皆对象，例如，人，电脑，桌子···等等。

面向对象的三大特性：封装，继承，多态。

在理解面向对象的三大特性之前，首先得清楚什么是类和对象？

类——对一切事物的抽象，比如：动物、人、桌子等等。

对象——是对类的实例化，比如动物类可以实例化为猫、狗等等，人类可以实例化为黄种人、白种人、黑人等等，桌子类可以实例化为书桌、餐桌等等。

封装性——面向对象的核心思想，就是把内部实现的细节封装起来。比如使用银行的ATM存取钱时，我们不知道该机器内如如何工作，但是当我们把卡插入卡口，通过外部的操作就可以完成存取钱的动作。

继承——描述的是类和类之间的关系。例如动物类和狗类，狗类有动物类的特性，但是狗类又在动物类的基础之上有一些自己特有的特性。

多态——是指类被继承后，产生不同的形态和行为。比如狗类和猫类都继承了动物类，但是对于动物类的叫声，狗的叫声是汪汪汪，猫的叫声是喵喵喵。

通过上述的描述，对象是通过类实例化出来的，也就是产生对象之前得先有类。

类与对象

• 类：类是对象的抽象，是用来描述一组对象共有的特征和行为，特征被称为类的属性，行为被称为类的方法。

• 对象：对象是类的具体化表现。

• 类与对象的概念是相对的

 Java中的类与对象

Java中的类

public class 类名{
    //数据类型 属性名;
    //...
    
    //方法
    //public void run(){
    
    //}
}

Java中的对象

数据类型 对象名 = new 数据类型();

属性和方法的使用

//访问属性
对象名.属性名;
​
//调用方法
对象名.方法名();

 方法

方法的定义

权限修饰符 [静态修饰符] 返回值 方法名([参数列表]){
    //方法体
}

• 修饰符：是对访问权限的限定，例如，public、static都是修饰符 
  • 返回值：被return语句返回的值，该值会返回调用者 
  • return关键字：用于结束方法以及返回方法指定类型的值 
  • 参数名：是一个变量，用于接收调用方法时传入的数据 
  • 参数类型：用于限定调用方法时传入参数的数据类型 
  • 返回值类型：用于限定方法返回值的数据类型 

方法重载

抽象类

抽象类的简介

被abstract修饰的类就叫抽象类。

抽象类的特征

• 如果一个类有抽象方法，那么这个类一定是抽象类

• 抽象类不能被实例化对象，但是可以有构造方法

• 子类继承抽象类，则需要把抽象中的抽象方法都实现,或者它也是抽象类

• 抽象类一定要有子类去实现它的抽象方法，否则抽象类没有意义

抽象类与普通类的区别

• 抽象类可以有抽象方法，普通类没有

• 抽象类不能new对象，普通类可以new对象

接口

接口的主要作用是定义标准和规范

接口的定义

public interface 接口名{
    //抽象方法
    //常量
}

接口定义出来后，要有实现类去实现该接口，否则该接口没有意义。

实现类的写法

public class 类名 implements 接口名{
    //实现抽象方法
}

接口的特征

* 1.接口不能创建对象，也没有构造方法
* 2.接口中的方法都是抽象方法，且默认都是public
* 3.接口可以继承接口，但不能实现接口
* 4.实现类在实现接口时，要将接口所有的抽象方法都实现，包括其父类的抽象方法
* 5.接口可以多实现

接口中定义常量

public static final 数据类型 常量名 = 值;
​
//常量名
常量名必须是全大写，多个单词之间用下划线间隔

接口中常量的使用

接口名.常量名

重载

• 发生在同类中，方法名相同，参数列表不同则为重载。

• 重载与返回值无关

多态

指的一种事物在不同的时候可表现出不同的形态。

多态的的分类

• 编译时多态：方法重载

• 运行时多态

  • 继承

  • 重写

  • 父类引用指向子类对象