Java语法基础

每天学一点

JVM、JRE和JDK的区别
- JVM(Java Virtual Machine)：Java虚拟机
- JRE(Java Runtime Environment) Java运行环境
- JDK(Java Development Kit) Java的开发工具
环境变量path和classpath的作用是什么？
GC是什么？为什么要有GC？
一个“.java”源文件中是否可以包含多个类(不是内部类)？有什么限制？
变量有什么用？为什么要定义变量？什么时候用？
Java的数据类型有哪些？
&& 和 & 的区别，|| 和 | 的区别
Char型变量中能不能存储一个中文汉字？为什么？
++i与i++的区别
short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗?
Java 中的final关键字有哪些用法？
swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？
两数之和Ⅱ-输入有序数组
- - 暴力法
  - 双指针

JVM、JRE和JDK的区别 JVM(Java Virtual Machine)：Java虚拟机

Java虚拟机是一个可以执行Java字节码的虚拟机进程
Java源文件被编译成能被Java虚拟机执行的字节码文件
用于保证Java的跨平台的特性
补充：Java中的所有类都必须装载到JVM中才能运行。Java类的装载主要通过类加载器才能完成。类加载器：将class文件从硬盘读取到内存中

JRE(Java Runtime Environment) Java运行环境

Java的运行环境，包括JVM+Java的核心类库

JDK(Java Development Kit) Java的开发工具

Java的开发工具，包括JRE+开发工具
可以让开发者开发、编译、执行应用程序

环境变量path和classpath的作用是什么？

Path是配置Windows 可执行文件的搜索路径，即扩展名为.exe的程序文件所在目录，用于指定DOS窗口命令的路径
Classpath是配置class文件所在的目录，用于指定类搜索路径，JVM就是通过它来寻找该类的class类文件的

GC是什么？为什么要有GC？

GC是垃圾收集的意思，垃圾回收可以有效地防止内存泄漏，有效的使用内存。
垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存推中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
Java提供GC功能可以自动检测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
可以调用下面的方法之一：System.gc() 或 Runtime.getRuntime().gc()，但JVM可以屏蔽掉显示的垃圾回收调用。

一个“.java”源文件中是否可以包含多个类(不是内部类)？有什么限制？

可以，但是一个源文件中最多只能有一个公开类(public class)而且文件名必须和公开类的类名完全保持一致。

内部类：有访问外部类成员的权限，通常被称为内部类。
私有内部类：内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符。
静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它。

 - class OuterClass {   // 外部类
 -     // ...
 -     class NestedClass { // 嵌套类，或称为内部类
 -         // ...
 -     }
 - }

变量有什么用？为什么要定义变量？什么时候用？

变量的作用：用来存储数据。
为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

Java的数据类型有哪些？

基本数据类型：byte short int long float double char Boolean
引用数据类型：类接口枚举注解数组
数据类型的相互转换
正向的过程: 从低字节向高字节可以自动转换（Java中的自动类型提升）
byte-> short-> int-> long-> float-> double
三种情况：
int -> float
long -> float
long -> double
特殊情况：char <-> int （相互转换）

package 基础;

class DataTypeDemo {
    public static void main(String[] args) {
        //定义变量的格式：
        //数据类型 变量名 = 初始化值;

        //定义一个字节变量
        byte b = 10;
        System.out.println(10);//10
        System.out.println(b);//10

        //定义一个短整型变量
        short s = 100;
        System.out.println(s);//100

        //定义一个整型变量
        int i = 1000;
        System.out.println(i);//1000

        //超过了int的范围
        //int j = 1000000000000;
        long j = 1000000000000L;//长整型后缀用L或者l标记。建议使用L。
        //long j = 100L;
        System.out.println(j);//1000000000000

        //定义浮点数据变量
        float f = 12.345F;//单精度浮点数用F或者f标记。建议使用F。
        System.out.println(f);//12.345

        //float f2 = (float) 12.3;
        float f2 = 12.3F;
        System.out.println(f2);//12.3
        double d = 12.345;
        System.out.println(d);//12.345

        double e = 12.3;//12.3
        System.out.println(e);
        //定义字符变量
        char ch = 'a';
        System.out.println(ch);//a

        //定义布尔变量
        boolean flag = true;
        System.out.println(flag);//true
    }
}

&& 和 & 的区别，|| 和 | 的区别

& , | 也可以在算术运算中使用；
(exp1) & (exp2) : exp1,exp2 都要执行
(exp1) | (exp2) : exp1,exp2 都要执行
(exp1) && (exp2) 若exp1 表达式返回false， exp2不执行，直接返回结果false （短路）
(exp1) || (exp2) 若exp1 表达式返回true， exp2不执行，直接返回结果true （短路）

package 基础;


class OperatorDemo3 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        //&&双与
        System.out.println((a > b) && (a > c)); //false && false = false
        System.out.println((a > b) && (a < c)); //false && true = false
        System.out.println((a < b) && (a > c)); //true && false = false
        System.out.println((a < b) && (a < c)); //true && true = true
        System.out.println("----------------");

        int x = 3;
        int y = 4;

        //boolean b1 = ((x++ == 3) & (y++ == 4));
        //System.out.println("x:"+x);//4
        //System.out.println("y:"+y);//5
        //System.out.println(b1);//true

        //boolean b1 = ((x++ == 3) && (y++ == 4));
        //System.out.println("x:"+x);//4
        //System.out.println("y:"+y);//5
        //System.out.println(b1);//true

        //boolean b1 = ((++x == 3) & (y++ == 4));
        //System.out.println("x:"+x);//4
        //System.out.println("y:"+y);//5
        //System.out.println(b1);//false

        boolean b1 = ((++x == 3) && (y++ == 4));
        System.out.println("x:"+x);//4
        System.out.println("y:"+y);//4
        System.out.println(b1);//false
    }
}

Char型变量中能不能存储一个中文汉字？为什么？

Char型bia能量是用来存储Unicode编码字符的，Unicode编码字符集包含了汉字，所以char型变量中可以存储汉字。只是，如果某个特殊的汉字没有被包含在Unicode编码字符集中，那么这个char型变量中就不能存储这个汉字。
Unicode编码占用两个字节，所以char类型的变量也占用两个字节。

++i与i++的区别

就近原则：

i++ 先赋值后自增,例如 a=i++,先赋值a=i,后自增i=i+1,所以结果是a=1
++i 先自增在赋值,例如 a=++i,先自增i=i+1,后赋值a=i,所以结果是a=2

package 基础;


class OperatorDemo2 {
    public static void main(String[] args) {
        //定义两个变量
        int x = 3;
        int y = 4;

        //字符串的拼接，字符串在前面
        //System.out.println("x:"+x);
        //System.out.println("y:"+y);

        System.out.println("x:"+x+",y:"+y);//3,4

        //单独使用
        //x++;
        //y--;
        ++x;
        --y;
        //System.out.println(x);
        System.out.println("x:"+x+",y:"+y);//4,3

        //意外的类型,常量是不可以这样做的
        //System.out.println(10++);

        System.out.println("-------------------");
        //参与运算使用
        int a = 3;
        int b = 4;

        //int c = a++;
        //int d = b--;

        int c = ++a; //++放在操作数前面，先自增或者自减，然后再赋值
        int d = --b;

        System.out.println("a:"+a); //4, 4
        System.out.println("b:"+b); //3, 3
        System.out.println("c:"+c); //3, 4
        System.out.println("d:"+d); //4, 3
    }
}

short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗?

对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。
short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

Java 中的final关键字有哪些用法？

修饰类：表示该类不能被继承，即不能有子类
修饰方法：表示方法不能被重写；
修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？

swtich可以作用在byte,short,int,char,枚举,String,Byte,Short,Integer,Character
从Java 7开始，expr还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。
简单表述：
因为在switch表达式中，表达式只能是整数int(Integer)或者枚举常量；由于byte，short，char可以自动转换为int

package 基础;


import java.util.Scanner;

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

        //控制键盘录入数据
        System.out.println("请输入一个数据(1-7):");
        int week = sc.nextInt(); //3

        //switch判断语句
        switch(week) {
            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;
            default:
                System.out.println("你输入的数据有误");
                break;
        }
    }
}

两数之和Ⅱ-输入有序数组

给定一个已按照升序排列的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

暴力法

使用双重for循环，第一次for循环每次选取一个数，第二次for循环每次从剩余的数中选取一个数，然后计算两数之和，将其值与目标值比较

class Solution{
	public int[] twoSum(int[] numbers,int target){
        int[] result = new int[2];
        for(int i=0;i
            for(int j=i+1;j
                if(numbers[i]+numbers[j]==target){
                    result[0]=i+1;
                    result[1]=j+1;
                }
            }
        }
        return result;
    }
}

双指针

class Solution{
	public int[] twoSum(int[] numbers,int target){
        int[] result = new int[2];
        //定义左侧指针left,指向数组中的第一个元素
        int left = 0；
        //定义右侧指针right,指向数组中最后一个元素
        int right = numbers.length-1;
        while(left < right){
            //如果左侧指针与右侧指针所指向的元素和等于目标值,则返回结果
            if(numbers[left]+numbers[right]==target){
                result[0]=left+1;
                result[1]=right+1;
                return result;
            }else if(numbers[left]+numbers[right]
                //如果左侧指针与右侧指针所指向的元素和小于目标值
                //因为数组是升序排列的,为了让两数之和变大一些
                //因此应将左侧指针向移动一位
                left++;
            }else if(numbers[left]+numbers[rught]>target){
                //如果左侧指针与右侧指针所指向的元素和大于目标值
                //因为数组是升序排列的,为了让两数之和变小一些
                //因此应将右侧指针向左移动一位
                right--;
            }
        }
        return result;
    }
}

Java语法基础

Java相关栏目本月热门文章