第一章 入门

1.1 计算机发展史和未来方向

第一代语言

机器语言

第二代语言

汇编语言 goto语法

第三代语言

java c c++

1.2 常见语言介绍

C

C++

面向对象
效率高

Java

最主流

PHP

web开发、中小型网站开发

Object-C & Swift

ios开发

JavaScript

H5开发核心就是JavaScript，其次HTML5\CSS

Python

图形处理、科学计算、web变成、人工智能

C#

微软、用来抗衡Java，运行于.Net Framework上
基于windows的桌面软件，c#是首选

Fortran

世界上第一种高级语言，IBM1954年提出，工程领域仍然广泛使用

Basic

易学，不够强大，已被淘汰

Pascal

仅限于大学教育，基本淘汰

1.3 Java

1.3.1 Java发展简史

1991年，James Goslings，SUN公司
1998年，JDK1.2
2004年，J2SE 5.0(1.5.0)
2014年，JavaSE8.0
赶上互联网的发展而发展

1.3.2 Java的核心优势

跨平台，强大的生态体系，第一大语言

1.3.3 Java各版本的含义

JavaSE：标准版，个人计算机应用（桌面应用），发展较差，不如C#

JavaEE：企业版，服务器端的应用

JavaME：微型版，消费型电子产品的应用，发展较差，不如安卓

1.3.4 Java的特性和优势

跨平台/可移植性

安全性

面向对象

简单性

高性能：虚拟机的优化，某些场景甚至接近C++效率

分布式

多线程

健壮性：不会造成计算机整体崩溃

1.3.5 Java应用程序的运行机制

高级语言主要有编译型和解释型语言，Java是两种类型的结合
首先编写原程序后缀为.java
再利用编译器javac编译成字节码文件，后缀为.class
最后利用虚拟机（解释器,java）解释执行

1.3.6 JVM、JRE和JDK

JVM Java虚拟机，与操作系统打交道

JRE 包含Java虚拟机、库函数、运行Java所必须的程序

JDK 包含JRE、编译器、调试器等应用程序开发的文件

1.4. JAVA安装

1.4.1 JDK下载和安装

略

1.4.2 环境变量Path的配置

略
JAVA_HOME：略
PATH： %JAVA_HOME%\bin
JDK1.5之后不需要配置classpath，JRE会自动搜索目录下类和jar文件

1.4.3 测试安装

略

1.5 编写

1.5.3 编码注意事项总结

1.Java对大小写敏感
2.public 是访问修饰符，控制其他部分对这段代码的访问级别
3.class类，java面向对象语言，代码都必须位于类中
4.一个源文件最多生命一个public类，其他类个数不限，且public 类名必须与源文件名一致
5.一个源文件可以包含多个类，编译后一个类对应一个class文件
6.main方法是入口，固定书写格式，public static void main(String[] args){……}
7.每句以分号结束

1.5.4 常用DOS命令

略

1.6 常用开发工具

eclipse
Intellij IDE
NetBeans

1.7 eclipse入门

1.7.1 eclipse下载和安装

下载版本要与JDK一致，64位eclipse支持64位JDK与32位JDK，32位eclipse支持32位JDK

1.7.2 eclipse中创建Java项目

1.8 桌球小游戏demo

略

第二章 数据类型和运算符

2.1 注释

单行//
多行/* /
文档/* */，说明及JavaDoc标签，可以生成API

2.2 标识符

字母、下划线、美元符号开头
其他部分可以使用字母、下划线、美元符号和数字任意组合
大小写敏感、长度不限制
不可以是Java关键字

使用规范
类名：首字母大写
方法和变量名：第一个单词小写，第二个单词开始首字母大写

Java不采用ASCII字符集，二是采用Unicode国际字符集，包括汉字，但是吧建议用汉字来定义标识符

2.3 Java中的关键字(保留字)

略

2.4 变量 variable

2.4.1 变量的本质

“可操作的存储空间”

基本类型 引用类型

一行中可以声明多个变量，但不建议这么写

int i,j;

2.4.2 变量的分类

局部变量 local variable：【从属：方法/语句块】先声明、再初始化，才能使用

成员变量 member variable：【从属：对象】类内部方法外部定义，从属对象，生命周期伴随对象始终；不初始化，会自动初始化成该类型的默认初始值。

静态变量 static variable：【从属：类】生命周期伴随类始终

2.5 常量 constant

通常指一个固定的值

一般用大写字母

利用final来定义

final double pi = 3.14;

2.6基本数据类型

三大类八小类（数字表示字节数）：

1. 数值型
   1.1. 整数类型：1 byte，2 short，4 int，8 long
   1.2. 浮点类型：4 float，8 double
2. 字符型
   2.1. 字符型：2 char
3. 布尔型
   3.1. 布尔型：1 boolean

2.6.1 整型变量/常量

1个字节8位

十进制

八进制，0开头，例如015

十六进制，0x或0X开头，例如0x15

二进制，0b或0B开头，例如0b110

long默认后面加L

long a = 2000000000L;

2.6.2 浮点型

小数默认是double，如果是float需要加F：

float a =3.14F;

浮点数不精确：

例1：

        float a = 0.1f;
        double b = 0.1;
        System.out.println(a==b);

结果

false

例2：

        float f1 = 423432423f;
        float f2 = f1+1;
        if(f1==f2) {
            System.out.println("f1==f2");
        }else {
            System.out.println("f1!=f2");
        }

结果

f1==f2

所以浮点数一定不能用来比较

如果要比较浮点数，需要用java.math下的BigDecimal和BigInteger

2.6.3 字符型变量/常量

2字节
unicode，65535个字符，含汉字

2.6.4 boolean布尔类型变量/常量

1位（不是1个字节），所以不能用0或非0代替true和false，这点和C不同

2.7 运算符

2.7.1 算数运算符

1. 二元运算符（+ - * / %）
   1.1 （整数）如果两个操作数有一个为Long，则结果也为Long
   1.2 （整数）没有Long时，结果为int。即使操作数全部为short、byte，结果也是int。
   1.3 （浮点数）如果两个操作数有一个为double，则结果为double
   1.4 （浮点数）只有两个操作数都是float，结果才是float
   1.5 （取模）操作数可以是浮点数，一般使用整数，结果是“余数”，“余数”符号和左边操作数相同
2. 一元运算符（++ --）

2.7.2 赋值及其扩展赋值运算符

a+=b;//相当于 a = a+b
a*=b+3;//相当于 a=a*(b+3)

2.7.3 关系运算符

注：

1. =是赋值运算符，而真正的判断两个操作数是否相等的运算符是==
2. ==、!=是所有（基本和引用）数据类型都可以使用
3. ">",">=","<","<="仅针对数值类型、char类型；char会自动转为unicode码数字（a=97）

        int a = 3;
        System.out.println(a==3);
        
        char b = 'a';
        char b2 = 'c';
        
        System.out.println((int)b);//97
        System.out.println(0+b);//97,int+char为int
        System.out.println(0+b2);//99,int+char为int
        System.out.println(b+0);//97,int+char为int
        System.out.println(b<b2);//true

2.7.4 逻辑运算符

& 逻辑与
| 逻辑或
&& 短路与，只要有一个false，则返回false
|| 短路或，只要有一个true，则返回true
！ 逻辑非，取反，！false为true，！true为false
^ 逻辑异或 ，相同为false，不同为true

注:

1. 逻辑与会计算所有结果再判断，短路与只要出现一个false即直接返回
2. 逻辑或只要出现一个true即直接返回

        System.out.println(true&false);//false
        System.out.println(true|false);//true
        System.out.println(true&&false);//flase
        System.out.println(true||false);//true
        System.out.println(!true);//false
        System.out.println(true^true);//false
        System.out.println(false^false);//false
        System.out.println(true^false);//true

2.7.5 位运算符

~ 取反
& 按位与
| 按位或
^ 按位异或
<< 左移运算符，左移一位相当于乘以2，两位是乘以2x2,三位是2x2x2
">>" 右移运算符，右移一位相当于除以2取商

        int a = 3;
        int b = 4;
        System.out.println(a&b);//0    3:0011 4:0100, 3&4 0000=0
        System.out.println(a|b);//7 3|4 0111=7
        System.out.println(a^b);//7 3^4 0111=7
        System.out.println(~a);//-4
        System.out.println(a<<1);// a*2 = 6
        System.out.println(b>>1);// b/2 = 2
        System.out.println(12>>2);// 12/2/2 = 3

2.7.6 字符串连接符

“+”
运算符两侧只要有一个字符串类型（String），系统会自动将一个操作数转换为字符串然后再进行连接

        int a = 3;
        String b = "4";
        int c = 4;
        System.out.println(a+b);//34
        System.out.println(a+c);//7
        
        System.out.println(a+b+c);//344 ，a+b先转为String
        System.out.println(a+c+b);//74  ，a+c先计算数字

注:

1. String + 数字 = String
2. char + 数字 = 数字

2.7.7 条件运算符

x ? y : z

x为boolean类型表达式，先计算x，若为true则返回y，否则返回z

        int score = 80;
        String type = score<60?"不及格":"及格";
        System.out.println(type);//及格
        
        int x = -100;
        System.out.println(x>0?1:(x==0?0:-1));//-1
        System.out.println(x<0?1:(x==0?3/0:3/0));//1  ，先计算外层，走不到里层括号，所以3/0不会报错

2.7.8 运算符优先级的问题

略

2.8 类型转换

2.8.1 自动类型转换

1. 容量小的可以自动转换为容量大的数据类型（不是字节数，而是范围，比如float4个字节可以转换为long8个字节，因为float范围大，但是会损失一定精度）。

2. 整型常量可以直接赋值给byte 、short、char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。

short a = 12;//合法
short b = 123456;//非法

2.8.2 强制类型转换

(type)var

2.8.3 基本类型转换溢出

操作比较大的数时，要留意是否溢出

        int money = 1000000000;//10亿
        int years = 20;
        int total = money * years;
        System.out.println(total);//-1474836480,溢出，int范围21亿
        long total2 = money * years;
        System.out.println(total2);//-1474836480,溢出，int计算先溢出，所以即使total2是long也不行
        long total3 = money * (long)years;
        System.out.println(total3);//20000000000,先强转其中一个为long，long与int计算还是long
        
        //常用技巧
        long total4 = 10L * 1000000000;//10000000000，直接将其中一个数字强转为long
        long total5 = 10  * 1000000000;//1410065408，溢出
        System.out.println(total4);
        System.out.println(total5);

2.9 简单的键盘输入

Scanner

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名字:");
        String name = scanner.nextLine();
        System.out.println("请输入你的爱好:");
        String favor = scanner.nextLine();
        System.out.println("请输入你的年龄:");
        int age = scanner.nextInt();

        System.out.println("#####################");
        System.out.println(name);
        System.out.println(favor);
        System.out.println(age);

结果

请输入名字:
pjh
请输入你的爱好:
coding
请输入你的年龄:
33
#####################
pjh
coding
33

第三章 控制语句

3.1 选择结构

任何一个软件和程序，本质都是由“变量、选择语句、循环语句”组成

3.1.1 if单选择结构

注意，if可以不写{}，只执行下面一句，但是建议即使是一句也要用{}

3.1.2 if-else双选择结构

if(布尔表达式){
    语句1
}else{
    语句2
}

3.1.3 if-else if-else多选择结构

if(布尔表达式1){
    语句1
}else if(布尔表达式2){
    语句2
}else{
    语句3
}

3.1.4 switch多选择结构

一般用来做多值判断

switch(表达式){
case 值1:
语句1;
[break;]
case 值2:
语句2;
[break;]
……
[default:
默认语句;]
}

遇到break结束switch；

表达式一般是整数（long除外）或者枚举，JDK1.7之后支持String；

如果判断到所需的值后没有break，会把后续所有语句执行；

例如：

        int month = (int)(1+12*Math.random());
        month = 3;
        System.out.println("月份:"+month);
        
        switch(month) {
        case 1:
            System.out.println("1月份过年了");
//          break;
        case 2:
            System.out.println("2月份开春了");
            break;
        case 3:
            System.out.println("3月开学了");
//          break;
        default:
            System.out.println("其他月份");
            break;
        }

结果：

月份:3
3月开学了
其他月份

3.2 循环结构

3.2.1 while循环

while(布尔表达式){
    循环体;
}

    graph TD
    
    开始 --> 布尔表达式
    布尔表达式 -- true --> 循环体
    循环体 --> 布尔表达式
    布尔表达式 -- false --> 结束
    

3.2.2 do-while循环

do{
    循环体;
}while(布尔表达式);

3.2.3 for循环

        int sum = 0;
        for(int i=1;i<=100;i++) {
            sum+=i;
        }
        System.out.println(sum);
        ////
        int j = 1;
        sum = 0;
        for(;j<=100;j++) {
            sum+=j;
        }
        System.out.println(sum);
        ////
        int k;
        for(k=0,sum=0;k<=100;k++) {
            sum+=k;
        }
        System.out.println(sum);

3.2.4 嵌套循环

99乘法表

        //99乘法表
        for(int i=1;i<=9;i++) {
            for(int j=1;j<=9;j++) {
                if(j<=i){
                    System.out.print(j + "*" + i + "=" + (i*j<10?" "+i*j:i*j) +"  ");
                }                   
            }
            System.out.println();
        }

结果：

1*1= 1  
1*2= 2  2*2= 4  
1*3= 3  2*3= 6  3*3= 9  
1*4= 4  2*4= 8  3*4=12  4*4=16  
1*5= 5  2*5=10  3*5=15  4*5=20  5*5=25  
1*6= 6  2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7= 7  2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8= 8  2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9= 9  2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81 

3.2.5 break & continue 语句

break用来退出循环，不执行循环中剩余语句
中止本次循环后续代码，继续下次循环

3.2.6 带标签的break & continue

goto语句，保留关键字，但java没有正式使用
break和continue中可以看到一些goto的影子--带标签的break和continue