初学JAVA01

初学JAVA

Java 特点： 1995年正式发布Java

    1跨平台性、2简单性（较C++）、3纯面向对象 （4开源）    ------------------------------------------------------    1.简单性        舍弃了运算符重载、多继承等不常用的、难以理解的、容易混淆的成分        增加了自动垃圾搜集功能，用于回收不再使用的内存区域，大大减少了由于内存分配而引发的问题        另外，简单性还体现在小上。Java解释器、系统模块和运行模块都比较小，适合在小型机器上运行，也适合在网上下载    2.面向对象        面向对象编程是一项有关对象设计和对象接口定义的技术，或者说是一项如何定义程序模块才能使它们“即插即用”的技术。        Java继承了C++面向对象技术的核心，更具有动态解决问题的特性。        对象通过继承和重定义，成为解决新问题的棋块，使代码重用有了可能。    3.网络适用性        Java提供了大量的系统模块支持基于TCP/IP协议的编程，使得Java建立网络连接更容易        Java程序通过URL访问网络资源和存取本地文件系统一样简单。    4.健壮性        Java提供早期的编译检查和后期的动态(运行期）检查，大量消除了引发异常的条件.    5.安全性        Java可以组建病毒无法入侵和无法篡改的系统，其数字验证使用了基于公共密钥的技术。        安全性和健壮性密切相关    6.结构中立        任何安装了Java运行环境的计算机都能执行Java编译生成的目标代码(字节码)。    7.可移植性        结构中立构成了可移植性的基础        Java语言的基本数据类型采取固定长度，例如int型数据在任何计算机上都是32位长(4个字节)        Java提供了可移植的接口        java本身也可以移植    8.解释型        Java是解释执行的。执行速度可以很快    9.高性能        字节码翻译执行很快    10.多线程        计算机同时运行多个程序段        Java提供了一套复杂的线程同步化机制，程序员可以方便的使用基于这种机制设计的方法，编写出健壮的多线程程序。    11.动态        Java是运行加载，类库可以自由添加方法和属性而不影响用户程序

Java运行机制：

编译 编译器：源文件 --> 机器码文件    （运行效率高）解释 解释器：源文件 --> 逐行翻译并运行 （可以跨平台）Java ———— 先编译 后解释    .java 源文件 --> .class 字节码文件 --> 在解释器中 解释运行JVM：Java虚拟机 屏蔽不同操作系统（OS）的差异JVM + 解释器 = JRE （Java运行环境）编译器+JRE+工具+类库 = JDK （Java开发工具包）

Java运行过程：

1、编译命令：javac 源文件名.java   ———— 几个类编译后就会生成几个.class（文件名相对应）2、运行命令：java 类名（一个类的全名）（包名.类名）一个源文件可以定义多个类(class)一个源文件只能定义一个公开类(public class)，公开类的类名必须和源文件名称完全相同

包：

package 包 ———— 写在程序第一句话 ———— 多个包用.隔开 如 package p1.p2.p3;    java p1.Hello    --> JVM会根据ClassPath（.）在当前目录下，找p1子目录，并在这个子目录中找Hello.classjavac –d 目标目录 源文件名.java         目标目录 --> 把生成的目录放在哪个目录下作为子目录。    javac -d . Hello.java ———— 生成的class自动放入包里（.指把包放入当前目录下）import 引入包，目的是避免重复写包名 —————— 书写在package之后 —— 让代码更简洁，可不写    *包里的所有类，但是不包括子包（即不能写.*.*）import java.lang.*;    系统默认添加    java.lang.String    java.lang.System

基本结构：

    package:0-1    import: 1-n    class:  1-n  公开类 0-1

注释：

    描述代码的文字 提高代码的可读性和可理解性    1. //        单行注释 （//往后）            写在代码的上部或后面    2. /*  */    多行注释 （里面允许嵌套单行注释，但不允许嵌套多行注释）    3./**  */    多行注释 配合JavaDoc工具使用 —— 写在需注释的前面  ———— 生成API文档

标识符_语法（必须）：

    1. 字母(中英文) 数字 _ $    2. 数字不能开头    3. 大小写敏感    4. 不能使用关键字和保留字   package import class public true false    5. 没有长度限制标识符_习惯：    1. 望文生义  提高可读性       2. 大小写        包名：全小写    com.baizhi.day2;        类名：单词首字母大写    HelloWorld        变量/函数名：首单词小写，后面的单词首字母大写    printStar        常量名：全大写    COUNT    //下划线常用于常量名的单词分隔

数据类型 变量

    数据类型：对象类型：无穷，定义的类class；              简单类型（基本类型、原始类型）：8种                    整型：                        byte    1B    -128 ~ 127                        short    2B    -32768 ~ 32767                        int        4B    -2147483648 ~ 2147483647                        long    8B    -2^63 ~ 2^63-1                字面值后加l或L                    浮点型：  科学计数法 如 1.4e10=1.4*10^10                        float    4B    单精度        必须字面值后加f或F                        double    8B    双精度        字面值后加d或D                    字符型：                        char    2B        用法 'A'  65  '\u0041' --（\u后加16进制）                            unicode编码方式   如 'A'=65                            char类型可以进行数学运算    char('A' + 'B')=131;                        转义字符    '\t'   跳格tab                                    '\n'   换行                                    '\''   打印‘                                    '\“'  打印“                                    '\\'   打印\                    boolean 布尔类型     字面值 true false                            java中boolean类型不能参与运算                String 字符串   字面值 "HelloWorld"                        只能参与加法运算    如"a"+"b"="ab"  "ab"+10="ab10"    java 强类型 变量类型必须和数据类型一致  (int a=1.5 --> a=1)    定义变量：变量类型 变量名；

类型转换：(类型)表达式

    自动类型转换    提升精度    强制类型转换    丢失精度    short i = short(int a)    a + b   自动类型提升        若a和b中有double ==> double        若a和b中有float  ==> float        若a和b中有long   ==> long            默认         ==> int        只要有String     ==> String

表达式

    变量和字面值用某个运算符连接的式子    表达式必须有固定的值

运算符

    + - * / %    =  += -+ *= /=        a+=3 不会类型提升 ==  a=a+3 会类型提升    %=                    a=4        a++  --> a=5  -->表达式=4    先赋值再+1                        a=4        ++a  --> a=5  -->表达式=5    先+1再赋值    == > < >= <= !=    &&逻辑与 ||逻辑或 !逻辑非   ——— 只能进行逻辑运算，短路性    比如判断&&前面为false后，直接进行最终判断    &按位求与 |按位求或 ^异或 ~求反(1变0,0变1)    -- 前三个也可以参与逻辑运算    (1&1为1，其他都为0)        ^ 相同为0,不同为1;                            ^ 参与逻辑运算时，同为真或假时，返回假，其他返回真    >> << >>>  移位运算符        10110>>1 --> 01011    右移一位除以2                                10110<<1 --> 01100  左移一位乘以2                                >>    算术右移    有符号的位移，保持符号不变                                >>> 逻辑右移    负数位移完变正数    ?: 三元操作符    如：(a>b)?3:2 ——> 判断a>b,true-->3,false-->2

局部变量 在函数内部定义的变量

    1.先赋值，后使用    2.作用范围：从定义开始，到它的代码块结束    //{}：一个代码块    3.在作用范围内，不允许两个局部变量发生命名冲突

读入数据

    读入数据的类： java.util.Scanner    代码：        java.util.Scanner sc = new java.util.Scanner(System.in);    //创建了一个 Scanner 对象,,为读入数据做准备        int n = sc.nextInt();          //读入一个整数        String str = sc.nextLine();  //读入一行字符串        double d = sc.nextDouble(); //读入浮点数        /*通过sc的相关函数 从控制台获取数据        next() 获取字符串 遇到空格或者回车结束        nextLine() 获取字符串 遇到回车结束        nextInt() 获取一个int类型的数据        nextDouble() 获取一个double类型的数据        nextBoolean() 获取一个boolean类型的数据        next().charAt(0) 获取一个字符        */

流程控制

    顺序执行流程    条件分支流程               if(){}        if(){}    else{}        if(){}    else if(){}    else{}        switch(i){            case 1: ;break;        //case后面的常量必须是整数或字符型            case 2: ;break;        //case后面的常量不能有相同的值            case 3: ;break;        //case后面通常使用break，提供一个出口，否则会落空            ……            default: ;        —— 前5个case都不能匹配的时候，执行default。        }                switch(i) —— i：只允许整型表达式  byte short int char                                    后续版本已支持 String                case后只能跟数字，不能跟范围    循环流程        while(布尔表达式){}            会执行0~n次        do{}        while(布尔表达式);                会执行1~n次        for(①赋值;②⑤⑧条件;④⑦语句){③⑥}       会执行0~n次                                    条件为空时，默认true；                                    for( ; ; )里面都可为空                                    确定循环次数时适合用for循环        break;     跳出循环        continue; 跳出本次循环/继续下一次循环        双重循环    循环的嵌套

函数(方法)：

    可以重复被使用的一段代码    定义位置：类中，其他函数的外部                一个类中，多个函数的顺序是无关紧要的    声明： public static 返回值类型 函数名（形参列表）            返回值:表示调用函数之后，函数会返回什么数据给调用者；(8种基本类型+对象类型)            形式参数（形参）：相当于函数内部有效的局部变量  ———— 多个形参用“,”隔开  如(int a,int b)            void 表示没有返回值    实现：{代码}                必须和声明一致（主要指返回值类型）                return;                    return 语句表示返回一个值                            还能够控制流程的跳转(结束函数)    调用函数：        函数名(实参列表);            实参会依次给形参赋值，，实参(表达式，字面值，变量)        调用函数，程序流程会进入函数，函数返回，程序流程会返回到函数调用点    函数的作用：        1.避免冗余代码        2.提高程序的可维护性        3.提高程序的重用性        4.提高程序的灵活性    函数的嵌套和递归        递归：函数自己调用自己   不是必须用              把一个大问题化解成小问题

编程思想：

    面向过程的编程：（自顶向下，逐步求精）        从程序执行的过程入手，将完整的过程细化成多个子过程，再将子过程细化，直到完成代码    非结构化： goto    结构化：   函数

一维数组：一个线性数据序列 (数组是有序元素的集合)

    一次性定义多个同类型的变量        int[] a;    数组空间在内存中必定是连续的    数组元素有默认值        数值类型数组 默认值：0/0.0        boolean类型数组 默认值：false        对象类型数组 默认值：null    int[] a = {1,2,3};                数组的显式初始化           ||    int[] a = new int[] {1,2,3};    数组的显式初始化           ||    int[] a;        数组的定义声明    a=new int[3];    初始化长度    a[0]=1;            数组中变量的赋值    a[1]=2;    a[2]=3;    for(int i = 0;i<a.length;i++){            //遍历数组：把数组中的元素从头到尾访问一遍        System.out.println(a[i]);    }    数组的长度： 数组名.length    数组长度是固定的，如果需要扩充，必须创建新数组，原数组的元素要复制到新数组    数组的扩充1：int[] a={1,2,3,4};                int[] b=new int[a.length*2];                for(int i=0;i<a.length;i++){                    b[i]=a[i];}                a=b;        //让a这个变量自此指向b地址,即把b指向的首地址赋值给a    数组的扩充2：int[] a={1,2,3,4};                int[] b=new int[a.length*2];                System.arraycopy(a,0,b,0,a.length);        //System.arraycopy(原数组，起始下标，目标数组，起始下标，数量)                a=b;    数组的扩充3：int[] a={1,2,3,4};                a=java.util.Arrays.copyOf(a,a.length*2);

二维数组：(机器识别为：一维数组的嵌套)

    int[][] a = new int[4][3];        4行3列    for(int i=0;i<a.length;i++){            //遍历数组        for(int j=0;j<a[i].length;j++){            System.out.print(a[i][j]+"  ");        }        System.out.println();    }    不规则数组:        int[][] a = new int[4][]    //先为数组指定高维长度，再分别指定低维长度。但是反过来是错误的。        a[0]=new int[3];        a[1]=new int[5];        a[2]=new int[2];        a[3]=new int[6];    int[][] a = {{1,2,3},{4,5,6},{7,8,9},{0,0,0}};       二维数组的显式初始化

数组的排序：(归纳法)

    冒泡排序法：两个相邻的元素相比较    int[] a={4,2,7,6,9,1,5};        int n = a.length;        for(int i=1;i<n;i++){            //外循环            for(int j=0;j<(n-i);j++){    //内循环                if(a[j]>a[j+1]){        //相邻两个，前面数值较大时                    int t = a[j];        //交换a[j]和a[j+1]的位置                    a[j] = a[j+1];                    a[j+1] = t;                }            }        }

选择排序法：选择一个元素后和其余元素相比较
//第一种：

      int[] a={4,2,7,6,9,1,5};        int n = a.length;        for(int i=0;i<(n-1);i++){        //外循环            for(int j=i+1;j<n;j++){        //内循环                if(a[i]>a[j]){            //选择的元素与其余元素比较时，前面数值较大时                    int t = a[i];        //交换a[i]和a[j]的位置                    a[i] = a[j];                    a[j] = t;                }            }        }        **//第二种：**      int[] a={4,2,7,6,9,1,5};        for(int i = 0;i<a.length-1;i++){            int min = i;    //min保存遍历范围内的最小值的下标            for(int j = i;j<a.length;j++){                if(a[min]>a[j]){                    min = j;                }            }            //a[i] <==> a[min];            int temp = a[i];            a[i] = a[min];            a[min] = temp;        }    **快速排序法：**        java.util.Arrays.sort();

---

快捷键

• 加粗 Ctrl + B

• 斜体 Ctrl + I

• 引用 Ctrl + Q

• 插入链接 Ctrl + L

• 插入代码 Ctrl + K

• 插入图片 Ctrl + G

• 提升标题 Ctrl + H

• 有序列表 Ctrl + O

• 无序列表 Ctrl + U

• 横线 Ctrl + R

• 撤销 Ctrl + Z

• 重做 Ctrl + Y