java基礎階段複習1

時間  2021-02-19
標籤 java 數組 oracle dom jvm 工具 開發工具 操作系統 code 欄目 Java 简体版
原文   原文鏈接

環境配置
JAVA_HOME:jdk的路徑(jdk下載網址：http://www.oracle.com)
Path:要把jdk的目錄路徑，添加到path變量java

java的運行工做原理
java源代碼文件(.java)-->java字節碼文件(.class)-->運行結果
.java-->.class:編譯期(經過javac命令將java的源文件編譯爲字節碼文件)
.class-->運行結果：運行期(先啓動java虛擬機，不一樣的操做系統有不一樣的jvm,所以java跨平臺,再經過JVM加載.class字節碼文件，並加載main方法執行程序)數組

jdk jre jvm 的關係
jdk（開發工具包）:Java Development Kit 是針對java開發員的產品，是整個Java的核心，包括了Java運行環境JRE,java工具和java基礎類庫。
jre（運行環境）:Java Runtime Envirment Kit是針對運行JAVA的運行環境，包含JVM和java的核心類庫。
jvm（Java虛擬機）:java Virtual Machine,java虛擬機的縮寫，是整個java實現跨平臺的最核心的部分，可以運行以java語言寫做的軟件程序。
jdk有不一樣系統的版本，因此jdk是跨平臺的oracle

java的一次編寫,到處執行是怎樣實現的?
java程序會被編譯成字節碼組成的class文件,這些字節碼能夠運行在任何平臺,所以java是平臺獨立的.dom

標識符
由字母,數字,下劃線(_),$組成,不能有空格和其餘字符,以及不能出現關鍵字.
不能由數字開頭
嚴格區分大小寫
見名知意jvm

八種數據基本類型
byte(1),short(2),int(4),long(8),float(4),double(8),char(2),boolean(1)工具

練習1(輸入我的信息):
public class Test1{
    public static void main(String[] args){
    System.out.println("姓名:");
    String name = new Scanner(System.in).nextLine();
    
    System.out.println("性別:");
    String sex = new Scanner(System.in).nextLine();
    
    System.out.println("年紀:");
    int age = new Scanner(System.in).nextInt();
    
    System.out.println("您輸入的我的信息是:");
    System.out.println("姓名:");
    System.out.println("性別:");
    System.out.println("年紀:");
    }
}
練習2(圓的面積):
public class Test2{
   System.out.println("請輸入圓的半徑:");
   double r = new Scanner(System.in).nextDouble();
   System.out.println(3.14*r*r);
}
練習3(變量的交換):
public class Test3{
    System.out.println("請輸入變量a:");
    int a = new Scanner(System.in).nextInt();
    
    System.out.println("請輸入變量b:");
    int b = new Scanner(System.in).nextInt();
    
    int t = a;
    a = b;
    b = t;
    System.out.println(a);
    System.out.println(b);
}

引用類型
引用類型是一個對象類型,其值是指向內存空間的引用,就是地址.開發工具

基本類型字面值規則
整數字面值是int(4)類型,若是值超出int範圍,則須要作轉型處理.
byte(1),short(2),char(2)三種比int小的整數,在自身範圍內能夠直接賦值.
浮點數字面值時double;浮點數轉成整數會直接捨棄小數點後6位.
字面值後綴:L,D,F
字面值前綴:二進制(0b);16進制(0x);8進制(0);char類型16進制(uui

基本類型的類型轉換
計算結果的類型與運算中的最大類型保持一致
byte(1),short(2),char(2)三種比int小的整數,計算時會自動轉爲int.
有long類型時,都會轉爲long類型.
char類型相加,提高爲int類型.
整數運算溢出:能夠添加後綴;
浮點數運算不精確的解決方法:
1.直接去除整數;
2.四捨五入(Math.round());
3.向上取整(Math.floor());
4.向下取整(Math.ceil());
5.StringBuffer,StringBuilder操作系統

基本類型之間的轉換
數字類型之間能夠互相轉換,從小到大自動轉換,從大到小須要強制轉型.
byte-->short-->int-->long
char-->int
int-->float/double/longcode

小轉大:隱式轉換
int a = 9;
long b = a;
大轉小:顯式轉換
int x = 10;
byte b =(byte)x;

運算符
&:短路與,a&b,a與b同時爲真時結果才爲真,有一個爲false均爲false.無論左邊是什麼結果都要繼續執行右邊
&&:邏輯與,有一個爲假即爲假,再也不繼續判斷,左邊是假,右邊忽略不執行.直接判斷爲真
|:短路或,a|b,a與b中有一個爲真即爲真,無論左邊是什麼結果都要繼續執行右邊.
||:邏輯或,有一個爲真即爲真即爲真,再也不繼續判斷.左邊是真,右邊忽略不執行,直接判斷爲真.

流程控制
switch:jdk1.7以前只能判斷byte,short,char,int,以後能夠判斷string.從成立的case無條件的穿透全部的case包括default直到結束,或者是遇到break,若是全部的條件都不成立的話就執行case.

switch(變量或表達式){
case1:
case2:
case3:
default;
}
練習1:數字匹配
public class Test{
public static void main(String[] args){
    int i = 3;
    switch(i){
          case1:
          System.out.println("1");
          break;
          case2:
          System.out.println("2");
          break;
          case3:
          System.out.println("3");
          break;
          default:
          System.out.println("default");
        }
    }
}
break:中 斷,跳出循環
countine:結束本輪循環進入下一輪循環

for循環:

for(變量賦值;執行條件;變量修改){
    代碼
}
練習1:打印正方形
for(int i = 1;i<5;i++){
    for(int j=1l;j<5;j++){
    System.out.println("*");
    }
    System.out.println();
}
練習2:打印倒三角
for(int i = 5;i>1;i--){
    for(int j = 0;j<i;j++){
    System.out.print("*");
    }
    System.out.print();
}
練習3:打印99乘法表
public class Test3{
    public static void main(String[] args){
    test();
    }
    private static void test(){
    for(int i = 1;i<=9;i++){
        for(int j=1;j<=i;j++){
        System.out.println(i+"*"+j+"="+i*j+" ");
           }
        System.out.println();
        }
    }
}

if分支

單分支:
if(判斷條件){
代碼 
  }
多分支:
if(判斷條件){
    代碼1
  }else{
   代碼2
    }
嵌套分支:
if(判斷條件1){
  代碼1
}else if(判斷條件2){
  代碼2
}else if{判斷條件3}{
  代碼3
}else{
  代碼4 
}
練習1:輸入年號,判斷平年閏年
public class Test1{
public static void main(String[] args){
System.out.println("年號:");
int y = new Scanner(Syetem.in).nextInt();
String r = "平年";
if(y%4==0){
if(y%100!=0){
    r="閏年";
    }
  }
  if(y%400==0){
  r="閏年";
  }
}
練習2:商品打折
接收輸入的原價,滿1000打9折,滿2000打8折,滿5000打5折.
public class test2{
    public static void main(String[] args){
    System.out.println("輸入總原價");
    double price = new Scanner(System.in).nextDouble();
    double nowprice = f(price);
    System.out.println(nowprice);
    }
    public static double f(double p){
    if(p>5000){
      p=p*0.5;
    }else if(p>2000){
      p=p*0.8;
    }else if(p>1000){
      p=p*0.9;
    }else{
      p=p;
    }
    return p;
}
練習3:統計學員得分
>90:優秀
80-90:良好
70-80:中等
60-70:及格
<60:不及格
public class test3{
public static void main(String[] args){
    double score = new Scanner(System.in).nextDouble();
    if(score>=100||score<=0){
    System.out.println("請輸入0-100範圍內的數");
    }
    if(score>=90 && score<=100){
    System.out.println("優秀");
    }else if(score >= 80 && score<90){
    System.out.println("良好");
    }else if(score >=70 && score<80){
    System.out.println("中等");
    }else if(score >=60 && score<70){
    System.out.println("及格");
    }else if(score < 60){
    System.out.println("不及格");
      }
    }
}
練習4:產生一個隨機數,和用戶一直在輸入的數字比較.
public class test4{
    public static void main(String[] args){
    find();
    }
    private static void find(){
    
    int i = new Random().nextInt(100)+1;
    System.out.println("請猜1-100之內的數字:");
    int a = new Scanner(System.in).nextInt();
    while(true){
    if(a>i){
    System.out.println("猜大了");
    }else if(a<i){
    System.out.println("猜小了");
    }else{
    System.out.println("猜對了");
    break;
            }
        }
    }

}

三種循環的區別
for:知道循環次數
while/do...while:當循環次數不肯定時
while:先判斷，再執行，不符合規則，不執行代碼
do while:先執行，再判斷。代碼至少被執行一次。

方法
被命名的代碼塊，方法能夠含參也能夠不含參。

修飾符 返回值 方法名（參數）{
    方法體；
}
public static void f(){

}
練習1:
public class test1{
    public static void main(String[] args){
    f1(9);
    }
    private static void f1(int a){
    return 10*a;
    }
}

方法的重載
方法的重載是指在一個類中有多個同名的方法，但每一個方法都有不一樣的參數（參數的類型，個數，順序不一樣）。程序在調用方法時，能夠經過傳遞不一樣個數和類型的參數和決定具體使用哪個方法。

練習：
public class test{
    public static void main(String[] args){
    int a = 3;
    int b = 9;
    String name = "jack";
    f1();
    f2(a);
    f3(a,b,name);
    }
    private static void f1(){
        return 0;
    }
    private static void f2(int a){
        return a*a;
    }
    private static void f3(int a,int b,String name){
        return a+b+name;
    }
}

數組
數組Array是用於存儲多個相同類型的數據的集合。想要獲取數組中的元素，能夠經過元素的下標來獲取，下標是從0開始的。
建立數組：

動態初始化：int[] a = new int[5];

靜態初始化：int[] b = new int[]{1,2,3,4,5};
           int[] c = {2,3,4,5,6};
練習1：
public class Test1(){
    public static void main(String[] args){
    f1();
    }
    private static void f1(){
    //靜態初始化建立數組
    int[] i = new int[]{1,2,3,4,5};
    System.out.println(Arrays.toString(i));
    
    //動態初始化建立數組
   char[] j = new char[4];
    j[0] = "c";
    j[1] = "h";
    j[2] = "a";
    j[3] = "r";
    System.out.println(Arrays.toString(j));    
    }
    //獲取數組的長度
    System.out.println(j.length);
}
練習2：建立隨機數組
public class Test2{
    public static void main(Stirng[] args){
    f();
    }
    private static void f(){
    int[] a = new int[5];
    for(int i = 0;i < a.length;i++){
    a[i] = new Random().nextInt(100)+1;
        }
        System.out.println(Arrays.toString(a));
    }
}

數組工具類Arrays
Arrays.toString(數組)：將數組鏈接成字符串
Arrays.sort(數組)：數組排序
Arrays.copyOf(數組，新的長度)複製數組長度爲一個指定長度的新數組。
System.arraycopy(原數組，原數組起始位置，目標數組，目標數組起始位置，複製的數量):不會建立新的數組，可是目標數組要事先存在。
Arrays.binarySearch(數組，目標值)：二分法查找，在有序數組中查找目標值下標。

冒泡排序
相鄰位置比較，從小到大排序，若是小就往前換，i表明從頭至尾遍歷數據。

升序：
public class Test1{
    public static void main(String[] args){
    int[] arr = new int[]{31,23,43,65,17,89,54,76};
    int[] arrnew = f1(arr);
    System.out.println(Arrays.toString(arrnew));
    }
    public static int[] f1(int[] a){
    //外循環控制比較次數
    for(int i = 0;i<a.length-1;i++){
    //內循環控制比較大小，循環次數和外循環同樣
        for(int j = 0;j<a.length-1;j++){
            if(a[j]>a[j+1]){
            int t = a[j];
            a[j] = a[j+1];
            a[j+1] = t;
            }
        }
    }
    return a;
    }
}

降序：
public class Test2{
    public static void main(String[] args){
        // f1();
        int[] arr = new int[] {1,2,4,2,1,8,9,3,2,4};
        int[] newarr = f2(arr);
        System.out.println(Arrays.toString(newarr));

    }
    private static int[] f2(int[] arr) {
        //外循環控制次數
        for(int i = 0;i<arr.length-1;i++) {
            //內循環控制大小
            for(int j = 0;j<arr.length-1;j++) {
                if(arr[j]<arr[j+1]) {
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        return arr;
    }

變量
通常經過三部分來描述變量.變量類型,變量名,變量值.
變量的使用原則:就近原則.

局部變量
定義在方法裏,局部代碼塊中,方法運行完內存就釋放完了.

成員方法裏
定義在類裏方法外.做用域是在整個類中,類消失了,變量才釋放.

public class Test1{
int a = 9;//成員變量
    {
    int x = 8;//局部變量
    }
    public static void main(String[] args){
    int sum = 10;//局部變量
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程