Java基础

Java基础

1.Java入门准备

1.1.JDK,JRE,JVM三者的关系，以及JDK、JRE包含的主要结构有哪些？

JDK=JRE+Java的开发工具（javac.exe,java.exe,javadoc.exe)

JRE=JVM+Java核心类库

1.2为什么要配置path环境变量？如何配置?

为了在人员路径下执行java命令。

JAVA_HOME=bin的上一层目录

path=%JAVA_HOME%in

path=%JAVA_HOME%jre

1.3常用的几个命令行操作有哪些？

cd

md

rd

del

cd..

cd/

1.4编译和运行上述代码的指令

编译：javac ChairMan.java //编译：javac+文件名

运行：java ChairMan //运行：java+类名

2.Java基础掌握

关键字

定义：被Java语言赋予了特殊含义，用做专门用途的字符串

特点：关键字中所有字母都为小写

用于定义类，函数，变量修饰符的关键字

abstract final static synchronized

用于定义类与类之间的关系

extends impements

用于定义建立实例及引用实例，判断实例的关键字

new this super instanceof

用于异常处理的关键字

try catch finally throw throws

基于包的关键字

package import

其他修饰符关键字

navite strictfp transient volatile assert

用于定义数据类型值的字面值

true false null

Java保留字

定义：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字

goto、const

标识符

定义：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符

技巧：凡是自己可以起名字的地方都叫标识符

定义合法标识符规则

1.由大小写英文字母，数字_或$组成

2.不能以数字开头

3.不可以使用关键字和保留字，但能包含关键字和保留字

4.Java中严格区分大小写，成都无限制

5.标识符不能包含空格。

Java中名称命名规范

包名:多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

变量

基本数据类型之间的运算规则

1.自动类型提升

结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型

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

2.强制类型转换

相当于自动类型提升的逆运算

强制类型转换，可能导致精度损失

运算符

算术运算符：+、-、*、/、%

对于使用strictfp关键字的的必须严格按照浮点数去计算。

关系运算符：==、!=、<、>、<=、>=

boolean运算符:&&、||

位运算符:&("与")、|("或")、^("异或")、~("非")、>>("左移")、<<("右移")

运算符优先级

String类型的使用

1.String属于引用数据类型

2.声明String类型变量时，使用""

3.Stirng可以和8种基本数据类型变量做运算，且运算只能时连接运算

4.运算结果仍然是String类型

 

subString(int a,int b)切取字串

+拼接

equals比较字符串内容相等

==比较是不是同一个字符串，是否放在同一个位置

charAt(int i)获得索引处字符

API

String（常量、不可变）

StringBuffer和StringBuilder（变量）

StringBuffer（线程安全、效率低，多线程推荐使用）

StringBuilder(线程不安全、效率高，单线程推荐使用)

append()追加字符串

toString返回一个String对象

枚举类型

BigInteger（大数）和BigDecimal（高精度）

for each循环

for(int element:a)
    System.out.println(element);

 

输入输出

进制

数组

杨辉三角代码

package com.huangui.exer;
​
import java.util.Scanner;
​
public class YangHuiTest {
    public static void main(String[] args) {
        Scanner inputScanner=new Scanner(System.in);
        int n=inputScanner.nextInt();
        int[][] yanghui=new int [n][n];
        for(int i=0;i<n;i++)
        {
            yanghui[i][0]=1;
        }
        
        for(int i=1;i<n;i++)
            for(int j=1;j<n;j++)
        {
            yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
        }
        
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<=i;j++)
            System.out.print(yanghui[i][j]+" ");
            System.out.println();
        }
            
            
    }
​
}

回形数

import java.util.Scanner;
​
public class RectangleTest 
{
    public static void main(String[] args) 
    {
        Scanner in = new Scanner(System.in);
        System.out.println("输入一个数字");
        int len = in.nextInt();
        int[][] arr = new int[len][len];
​
        int s = len * len;
        int k = 1;
        int i = 0, j = 0;
        for (int m = 1; m <= s; m++) //m从1开始放入s个
        {
            if (k == 1) 
            {
                if (j < len && arr[i][j] == 0)
                    arr[i][j++] = m;
                else 
                {
                    k = 2;//换方向
                    i++;//i这一行已经放了，所以到下一行
                    j--;//j = len 是跳出的，所以j回退一个
                    m--;//m也回退一个
                }
            } 
            else if (k == 2) 
            {
                if (i < len && arr[i][j] == 0)
                    arr[i++][j] = m;
                else 
                {
                    k = 3;
                    i--;
                    j--;
                    m--;
                }
            } 
            else if (k == 3) 
            {
                if (j >= 0 && arr[i][j] == 0)
                    arr[i][j--] = m;
                else 
                {
                    k = 4;
                    i--;
                    j++;
                    m--;
                }
​
            } 
            else if (k == 4) 
            {
                if (i >= 0 && arr[i][j] == 0)
                    arr[i--][j] = m;
                else 
                {
                    k = 1;
                    i++;
                    j++;
                    m--;
                }
            }
        }
        for (int[] row : arr) 
        {
            for (int odd : row)
                System.out.printf("%4d", odd);
            System.out.println();
        }
    }
}

​

生成随机数

    //随机产生一个二位数
        int randomnum=(int)(Math.random()*90+10);

　　　　　

数组的赋值与复制

public class ArrayExer2 {
​
​
    public static void main(String[] args) {
        int[] array1,array2;
        array1=new int[] {2,3,5,7,11,13,17,19};
        for(int i=0;i<array1.length;i++) {
            System.out.println(array1[i]+"	");
        }
        
        //数组赋值，地址相等，两个数组是同一个
        //将array1保存的数组的地址值赋给array2,使得array1和array2共同指向堆空间中的同一个数组实体
        array2=array1;
        
        //数组的复制，真正的复制
        //通过new的方式，给array2在堆空间中开辟了数组的空间。将array1数组中的元素值一个一个的赋值给array2数组中。
        array2=new int[array1.length];
        for(int i=0;i<array2.length;i++) {
            array2[i]=array1[i];
        }
        
        
        //修改array2的值，array1的值也变了
        for(int i=0;i<array2.length;i++) {
            if(i%2==0) {
                array2[i]=i;
            }
        }
        System.out.println();
        
        for(int 
            =0;i<array1.length;i++) {
            System.out.println(array1[i]+"	");
        }
    }
}

二分查找

import java.lang.reflect.Array;
import java.util.Arrays;
​
import javax.swing.plaf.basic.BasicInternalFrameTitlePane.IconifyAction;
​
public class BinararySerach {
    
    public static void main(String[] args) {
        int[] arr2=new int[] {-98,-33,-97,44,70,79,97,45};
        //Java排序的类
        Arrays.sort(arr2);
        
        int dest=70;
​
        int head=0;
        int rear=arr2.length-1;
        
        boolean isFlag=true;
        while(head<=rear) {
            int middle=(head+rear)/2;
            if(dest==arr2[middle]) {
                System.out.println("指定元素，位置为"+middle);
                isFlag=false;
                break;
            }else if(arr2[middle]>dest) {
                rear=middle-1;
            }else {
                head=middle+1;
            }
        }
        
        if(isFlag) {
            System.out.println("很遗憾，没找到");
        }
    }
    
​
    
}

​

数组中常见的异常？请举例说明

ArrayIndexOutOfBoundsException:数组角标越界异常

NullPonterException:空指针异常