1、Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。java由SUN公司开发，2009年被Oracle（甲骨文）公司收购；

2、Java语言特点

2.1、简单性

java中不在支持多继承，Java中也屏蔽了指针的概念

java语言的底层是c++实现，不是C语言

2.2、面向对象

java是纯面向对象的，更符合人的思维模式，更容易理解

2.3、可移植性

java可以做到一次编译，到处运行，java程序在windoes系统上运行，不做任何修改就可以在Linux系统上运行。

java程序运行在一台虚拟的计算机当中（JVM）然后让JVM链接底层的操作系统

2.4、多线程

2.5、健壮性

java语言中产生的垃圾是自动回收的，（GC机制）

3、java的加载与执行

3.1、java的执行有两个重要的阶段

-编译阶段

-运行阶段

3.2、编译阶段

-编译阶段主要的任务是检查java源程序是否符合语法，符合语法就会生成（XXX.class）文件，也叫字节码文件

-字节码文件不是纯二进制的，无法直接在操作系统中执行

-编译使用的是JDK中自带的javac.exe命令进行的使用方法：在DOS窗口用（javac 类名.java）

-javac是java的编译工具

3.3、运行阶段

-JDK安装后，除了自带的javac.exe之外还有一个java.exe-在DOS窗口中使用（java 类名）就可以运行，不需要写（java 类名.class）

开始第一个java程序

1、安装JDK（这里安装JDK1.8）

JDK从Oracle官网下载（自行下载）

官网地址：Java Downloads | Oracle

2、安装文本编辑器Editplus

长这个样子

官网地址：EditPlus - Text editor with FTP, FTPS and sftp capabilities

3、JDK目录介绍

JDK/bin目录下存放了很多指令，例如javac.exe、java.exe

javac负责编译

java负责运行

4、JDK、JRE、JVM的关系

JDK：是java语言的开发工具包，

JRE：是java的运行环境

JVM：是java虚拟机，java运行时的环境

关系如下

5、配置环境变量

1、复制 bin目录的路径如：C:\Program Files\Java\jdk1.8.0_171\bin

2、我的电脑右键属性；

3、点高级系统设置

4、点环境变量

5、在下方找到Path，双击打开

6、点击新建，然后把复制的路径粘贴进去，一直确定就好

7、然后打开DOS命令窗口输入 java

这样就算成功了

6、用 Editpuls写第一个程序

1、在文件夹里新建一个文本文档，名字叫Hello.java，后缀名字改成java，如果电脑不显示后缀名在菜单栏中勾选显示后缀名；

新建的文件如下

2、然后右键选择 Editpuls 打开，编写第一个程序，不需要懂意思，照抄就好

代码如下：

2、打开存文件的路径，输入cmd 回车

7、编译：

在弹出的DOS窗口中输入 javac Hello.java 然后回车如下就是编译成功了

成功后会生成Hello.class文件

8、运行

继续输入java Hello 回车就会输出 “Hello world!”

9、使用java集成工具IDEA进行开发

9.1、Idea工具

9.2、 IDEA工具的使用

1、安装好IDEA之后，先创建一个空的progect；

2、然后再新建一个module

3、然后就可以在module下创建java文件进行写代码了

4、运行在代码窗口右建点击（Run xx.main()）

9.3、IDEA工具常用快捷键

IDEA常用快捷方式入口

java语言基础（从这里开始就正式进入java的学习）

1、java的主类结构

2、基本数据类型

2.1、数据类型概述

2.1.1、java中数据类型包括两种

-基本数据类型

-引用数据类型（这里讲的基本数据类型）

2.1.2、关于基本数据类型

-基本数据类型包括四大类，八小种

第一类：整数型

byte、short、int、long

第二类：浮点型

float、double

第三类：布尔型

boolean

第四类：字符型

char

2.1.3、字符串 "abc" 属于引用数据类型，字符属于基本数据类型

字符串使用的是双引号，字符使用单引号

2.1.4、八种基本数据类型

2.2、字符型

2.2.1、字符型用 char 修饰

2.2.2、示例：

2.3、整数型


public class Hello {
    public static void main(String[] args) {
        //定义byte
        byte b=20;//byte取值范围-128~127，注意别越界
        //短整型
        short s=200;
        //整形
        int i=100;
        //长整型
        long l=300;
    }
}

2.4、浮点型


public class Hello {
    public static void main(String[] args) {
        //定义单精度
        float f=3.14f;//有效位6~7位
        /*
        在java语言中，所有浮点数都当做double类型处理，
        想要当做float处理，要在末尾加 f；
         */
        //定义双精度
        double d=3.1415926;//有效位15位
        /*
         float 占用4字节
        double 占用8个字节，精度较高
        
        double 和float在计算机内部存储的都是近似值
         */
        
        
    }
}

2.5、boolean类型


public class Hello {
    public static void main(String[] args) {
        //布尔类型只能取true和false两种结果
        boolean b1=true;//这里不能写1或0；只能写true或false；
        boolean b2=false;
        
        /*
        true表示真 
        false表示假
        
        在计算机底层存储Boolean的时候，true底层用1，false底层用0；
        所以boolean只占用一个字节
        */
    }
}

2.6、数据类型之间的相互转换

转换规则

1、八种数据类型之间除了boolean以外，剩下的都可以相互转换

2、小容量往大容量转换，称为自动类型转换，容量从小到大排序：

注意：任何浮点数不管占多少字节，都比整数型容量大，cahr和short表示的种类数量相同，但是char可以取更大的正整数；

3、大容量转换成小容量的时候叫做强制类型转换，需要加强制转换符；编译阶段通过，运行阶段会损失精度，谨慎使用：


public class Hello {
    public static void main(String[] args) {
       short s;
       long l=200;
       char c='a';
       //强制转换
        //long 转换成short
        s=(short)l;
        /*输出*/
        System.out.println("s="+s);// 输出s=200
        //char转换成short
        s=(short) c;
        /*输出*/
        System.out.println("s="+s);//输出 s=97（a的ASCII码为97）
        
        int i=10;
        //编译会报错，因为编译器只仅检查语法，不会运算i/5；所以不知道结果有没有超出取值范围，所以报错
        byte b=i/5; 
        
    }
}

4、byte、short、char在混合运算的时候，各自先转换成int在做运算；

5、多种数据类型混合运算，先转换成最大容量的那种类型在做运算；

3、变量与常量

3.1标识符与关键字

3.1.1、在java中，凡是需要程序员有权利自己命名的单词就是标识符

标识符可以是：

-类名

-方法名

-变量名

-常量名

-接口名........

3.1.2、标识符命名规则（不遵守编译会报错）

-标识符只能由“数字”、“字母”、下划线_、美元符号$、组成，不能有其他符号

-不能以数字开头

-关键字不能做标识符

3.1.3、标识符命名规范（不属于语法）

-见名知意；

-遵守驼峰命名方式

例如：UserName，Student，SystemService

-类名、接口名：首字母大写，后面每个单词的首字母大写；

-变量名、方法名：首字母小写，后面每个单词的首字母大写；

-常量名：全部大写

3.1.4、关键字

向上面讲的 byte、short、int、long、float、double、public、class、static....

这些都是关键字

3.2、声明变量和常量


public class Hello {
    public static void main(String[] args) {
       //声明变量
        int i=10;
        //对i重新赋值
        i=100;
        /*
        变量可以在程序中多次赋值
         */
        //声明常量 用final关键字修饰
        final double PI=3.14;
        //这里会报错，因为用final修饰的常量不能再次赋值
        PI=5.36;
    }
}

3.3成员变量和局部变量


public class Hello {
    //成员变量（在整个类中都可以调用）
    //其他方法也可以调用
    int id=10;
    String name="zhangsan";
    
    //sum方法
    public void sum(int a,int b){
        //局部变量（只有在这个方法中有用，其他方法不可以调用）
        int cord=30;
        
    }
 
}

4、运算符

4.1、算数运算符

+：求和

-：相减

*：乘积

/：除

%：取余数

++：自加一

--：自减一

示例代码：


public class Hello {
    public static void main(String[] args) {
        int a=10;
        int b=3;
        //进行运算
        int c=a+b;
        int d=a-b;
        //也可以直接输出
        System.out.println(a+b);//13
        System.out.println(a-b);//7
        System.out.println(a/b);//3
        System.out.println(a*b);//30
        System.out.println(a%b);//1
        System.out.println(++a);//11  这个意思是a自身先加一，然后再输出
        System.out.println(--b);//2   这个意思是b自身先减一，然后再输出
        System.out.println(a++);//a++意思是a先进行输出，输出之后在进行自身加一
        System.out.println(b--);//b--意思是b先进行输出，输出之后在进行自身减一
 
    }
 
}

4.2、关系运算符

>: 大于

>=:大于等于

<:小于

<=:小于等于

==:等于

!=:不等于

=：是赋值运算符

==：是关系运算符

关系运算符的结果一定是Boolean类型：true/false；

示例代码：


public class Hello {
    public static void main(String[] args) {
        int a=10;
        int b=3;
       int c=10;
        System.out.println(a==b);//false
        System.out.println(a>b);//true
        System.out.println(a<b);//false
        System.out.println(a!=c);//false
        System.out.println(a!=b);//true
       
 
    }
 
}

4.3、逻辑运算符

&：逻辑与（两边的结果都是true结果才为true）

|：逻辑或（两边的结果有一个为true 结果才是true）

！：逻辑非（取反！false 就是true）

^：逻辑异或（两边的结果只要不一样，结果就是true）

&&：短路与

||：短路或

1、逻辑运算符要求两边都是boolean类型，结果也为boolean类型

2、短路与和逻辑与运算结果是相同的，只是短路与存在短路现象

3、例如：（1）&&（2）运算的时候如果1为false 2就不会在计算了，这种现象称为短路现象

示例代码：


public class Hello {
    public static void main(String[] args) {
        int a=10;
        int b=3;
       int c=10;
        boolean n= a>b && b>c; //这个相当于 true && false  结果为false
        boolean n2=a>b || b>c;// 相当于 true || false 结果为true
        System.out.println(n); //flase
        System.out.println(n2); //true
    }
}

4.4、赋值运算符

基本的赋值运算符

扩展的赋值运算符

+=；例如：a+=b 相当于 a=a+b;以下同理

-=；

*=；

/=；

%=；

赋值运算符优先级：先执行等号右边的表达式，将执行的结果赋给左边的变量

示例代码：


public class Hello {
    public static void main(String[] args) {
        byte a=10;
        long b=3;
       int c=10;
        a+=5;//相当于：a=(byte)(a+5);
        b+=6;//相当于：b=(long)(b+6)
        c+=a;//相当于 c=(int)(c+a)
 
    }
}

4.5、连接运算符“+”

+运算符的两个作用：

1、加法运算，当加号两边都是数字的话就进行加法运算

2、连接字符串，当加号两边只要有一个是字符串，一定会进行字符串连接运算

当在一个表达式中有多个“+”，在没有括号的前提下，遵循自左向右依次运算

示例：


public class Hello {
    public static void main(String[] args) {
       String s="hello!";
       String n=s+"java";
        System.out.println(n);//hello!java
    }
}

4.6、三元运算符

4.6.1、语法规则：

boolean表达式？表达式1 ：表达式2；

4.6.2、三元运算符执行原理

-当boolean表达式为true时，执行表达式1，

-当boolean表达式为false时，执行表达式2；

示例代码：


public class Hello {
    public static void main(String[] args) {
        System.out.println(10>3?"是的!":"不是");//是的
    }
}

流程控制

1、接受用户从键盘输入


//导入Scanner类
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        //创建Scanner（扫描器对象）
        Scanner sc=new Scanner(System.in);
        //从键盘输入(去掉println后面的ln可以输出后不换行)
        System.out.print("请输入:");
        int i = sc.nextInt();
        //以下都可以输入
        /*String s=sc.nextLine();
        double d=sc.nextDouble();
        boolean b=sc.nextBoolean();*/
 
        System.out.println("您输入的是:"+i);
 
    }
}

运行结果

2、条件语句

2.1、if条件语句

1.1.1、语法结构（一共四种）

表达式为true执行if后面的语句，表达式为false执行else后面的语句

如下：


public class Hello {
    public static void main(String[] args) {
        //第一种
        if(boolean表达式){
            //java语句;
            //java语句;
        }
        //第二种
        if(boolean表达式){
            //java语句;
            //java语句;
        }else {
            //java语句;
            //java语句;
        }
        //第三种
        if(boolean表达式){
            //java语句;
            //java语句;
        }else if(boolean表达式){
            //java语句;
            //java语句;
        }else if(boolean表达式){
            //java语句;
            //java语句;
        }.......
        //第四种
        if(boolean表达式){
            //java语句;
            //java语句;
        }else if(boolean表达式){
            //java语句;
            //java语句;
        }else if(boolean表达式){
            //java语句;
            //java语句;
        }else{
            //java语句;
            //java语句;
        }
    }
}

注意：对于java中的if语句来说，只要有一个分支执行，整个Java语句结束；

所有控制语句都是可以嵌套的，只要合理嵌套就行；

例题：使用if语句实现酒店座位的分配，根据人数安排客人到4人桌、8人桌、或者包厢用餐；

代码如下：


public class Hello {
    public static void main(String[] args) {
        System.out.println("欢迎光临，请问有多少人用餐？"); // 输出问题提示
        int count = 9; // 用餐人数
        System.out.println("回答：" + count + "人");// 输出回答
        if (count <= 4) { // 如果人数小于4人
            System.out.println("客人请到大厅4人桌用餐"); // 请到4人桌
        } else if (count > 4 && count <= 8) { // 如果人数在4-8人之间
            System.out.println("客人请到大厅8人桌用餐"); // 请到4人桌
        } else if (count > 8 && count <= 16) { // 如果人数在8-16人之间
            System.out.println("客人请到楼上包厢用餐"); // 请到包厢
        } else { // 当以上条件都不成立时，执行的该语句块
            System.out.println("抱歉，我们店暂时没有这么大的包厢！"); // 输出信息
        }
    }
}

2.2、Switch多分支语句

2.2.1、完整地Switch语句


public class Test01 {
    public static void main(String[] args) {
        //完整地Switch语句
        Switch(值){
            case 值1 :
                //java语句
                ...
                break;
            case 值2:
                //java语句
                ...
                break;
            case 值3 :
                //java语句
                ...
                break;
            ...
            default:
                //java语句
                ...
        }
 
    }
}

2.2.2、Switch语句的执行原理

1、Switch后面的括号中的数据和case后面的数据进行一一匹配，匹配成功的分支执行后面的语句，按照自上而下的顺序进行匹配。

2、分支当中有break语句的话整个Switch语句终止

3、匹配成功的分支执行，分支当中没有break的话，直接进入下一个分支执行（不进行匹配），这种现象叫case穿透现象。

4、如果所有语句都没有匹配成功，则会进入default的语句中执行

5、Switch后面的值只能是int、String类型的数据，不能是其他类型

6、byte、short、char可以直接写在Switch后面，因为会进行自动类型转换；

7、case可以合并例如：


public class Test01 {
    public static void main(String[] args) {
        int a=10;
        switch (a){
            case 1: case 2: case 3:
                System.out.println("春季!");
                break;
            case 4: case 5: case 6:
                System.out.println("夏季!");
                break;
            case 7: case 8: case 9:
                System.out.println("秋季!");
                break;
            case 10: case 11: case 12:
                System.out.println("冬季!");
                break;
            default:
                System.out.println("输入错误!");
        }
    }
}

3、循环语句

3.1、while循环、for循环、do..while循环

1、语法格式：


public class test02 {
    public static void main(String[] args) {
        //for语句
        for(初始化表达式;布尔表达式;更新表达式){
            //需要重复的语句（循环体）
        }
        //while语句
        while(布尔表达式){
            //循环体
        }
        //do..while语句
        do{
            循环体
        }while(布尔表达式);//分号不能少
    }
}

示例代码：


public class test02 {
    public static void main(String[] args) {
        //for语句
        System.out.println("for语句输出");
        for(int i=1;i<11;i++){
            //循环输出1到10
            System.out.print("i="+i+" ");
        }
        System.out.println();
        //while语句
        System.out.println("while语句输出");
        int i=1;
        while(i<11){
            System.out.print("i="+i+" ");
            //更新语句
            i++;
        }
        System.out.println();
        //do..while语句
        //do..while语句是先执行一次循环体，在进行判断
        //之前的两个是先进行判断在执行循环体
        System.out.println("do..while语句输出");
        int j=1;
        do{
            System.out.print("j="+j+" ");
            //更新语句
            j++;
        }while(j<11);//分号不能少
    }
}

执行结果：

4、控制语句

4.1、break语句

1、break是java中的关键字，翻译为：中断；

2、break；是一个单独的完整地语句；

3、break在Switch语句中用来终止Switch语句的执行；

4、break在循环语句中用来终止循环语句的执行，例如用在while语句中，同样用在for语句，do..while语句中；

5、若是有多个循环嵌套，break只会跳出当前break语句所在的那层循环；

4.2、continue语句

1、continue表示：继续的意思；

2、continue；也是一个单独的语句，他的意思是意思是中断本次循环，开始下一次循环；

4.3、break和continue的区别

break：中断循环，循环不在执行

continue：中断本次循环，直接进入下一次循环；

使用标签可指定跳出的位置：

语法格式

标签名：............

循环体

break/continue 标签名；//从这可以直接跳转到上面的标签名

4.4、break和continue示例代码：


public class Test03 {
    public static void main(String[] args) {
        //break语句示例
        System.out.println("break语句示例输出");
        for(int i=1;i<11;i++){
            //如果i等于3终止
            if(i==3){
                break;
            }
            System.out.print("i="+i+" ");
        }
        System.out.println();
        //continue语句示例
        System.out.println("continue语句示例");
        for(int i=1;i<11;i++){
            //如果i等于3中断，开始下次循环
            if(i==3){
               continue;
            }
            System.out.print("i="+i+" ");
        }
    }
}

运行结果：

方法

1、方法概述

1.1、方法的本质

-方法的本质就是一个代码片段，并且这个代码片段可以完成某个特定的功能，并且可以重复使用；

-方法对应的英语单词是：Method

-方法相当于C语言中的函数

1.2、方法的语法结构：

[修饰符列表] 返回值类型方法名(形式参数列表){

方法体；

}

- 关于修饰符列表

1、修饰符列表不是必须的，目前只写成public static

2、方法用static修饰的话，叫做静态方法，调用静态方法：

-类名.方法名（实参列表）

-关于返回值类型

1、一个方法执行完成后有的是需要将最终结果返回给调用者，返回值类型就是返回结果的数据类型

2、java中任何一种类型都可以做返回值类型

3、如果这个方法不需要返回值，那么返回值类型就写 void 例如：


public class Test04 {
    public static void main(String[] args) {
        //调用print方法
        Test04.print();
        //调用sum方法,把返回值赋值给num
        int num=Test04.sum(3,4);
        //输出
        System.out.println(num);
 
    }
    //定义一个没有返回值得方法
    public static void print(){
        System.out.println("hello!");
    }
    //定义一个有返回值的方法（返回值类型为int）
    public static int sum(int a,int b){
        //返回a+b
        return a+b;
    }
}

运行结果：

-关于return关键字

1、只要return语句执行，return所在的方法结束

-关于方法名

1、方法名最好见名知意

2、方法名首字母最好小写，然后后面每个单词首字母大写

-关于形式参数列表

1、形参是局部变量

2、一个方法的形参可以有多个

-关于方法调用

1、方法只定义不调用是不会执行的，只有在调用的时候才会执行

2、调用的时候传递的参数一定要与形参的类型一样，数量一样，顺序一样，不然就会报错

3、方法调用如果调用者和方法在同一个类中，类名可以省略

-方法示例代码


public class Test04 {
    public static void main(String[] args) {
        //调用print方法（方法调用如果调用者和方法在同一个类中，类名可以省略）
        print();
        //调用sum方法,把返回值赋值给num
        int num=Test04.sum(3,4);
        //输出
        System.out.println(num);
        //调用abc方法
        Test04.abc("张三",101,true);
 
    }
    //定义一个没有返回值得方法
    public static void print(){
        System.out.println("hello!");
    }
    //定义一个有返回值的方法（返回值类型为int）
    public static int sum(int a,int b){
        //返回a+b
        return a+b;
    }
    //定义一个方法
    public static void abc(String s,int a,boolean b){
        System.out.println(s+"的编号为:"+a);
        //使用了三目运算符
        System.out.println(s+"是否做了核酸:"+(b?"是":"否"));
    }
}

运行结果：

2、方法重载机制

-说明：方法重载机制就是同时可以定义方法名相同，形参列表的数据类型、或者数量等不同，调用这些方法的时候感觉就跟调用一个方法的一样，这就是方法重载机制

1、方法重载机制又称为：overload

2、当方法的功能类似，尽可能让方法同名，让方法重载

3、满足什么条件才能方法重载

*在同一个类中

*方法名相同

*参数列表不同（数量不同，类型不同，顺序不同）

4、方法重载和方法名+参数列表有关系，方法重载和返回值类型无关，和修饰符列表无关

-方法重载机制示例代码：


public class Test04 {
    public static void main(String[] args) {
        //调用方法
        Test04.sum(10,20);
        int num=Test04.sum(10,20,30);
        //在同一个类中，调用方法的时候类名可以省略
        sum("张三",22);
        System.out.println("三个数之和为："+num);
 
    }
    public static void sum(int a,int b){
        System.out.println("两数之和为："+(a+b));
    }
    public static void sum(String s,int a){
        System.out.println(s+"今年"+a+"岁!");
    }
    //带有返回值的方法
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
 
}

运行结果：

3、方法的递归调用

1、方法的递归调用就是方法自身调用自身

2、递归一定要有结束条件，没有结束条件一定会发生内存溢出错误

示例代码：


public class Test05 {
    public static void main(String[] args) {
        int b=diGui(0);
        System.out.println("最终结果:"+b);
    }
    public static int diGui(int i){
        i++;
        System.out.println("第"+i+"次调用");
        if(i<5){
            //递归调用
            diGui(i);
        }
        return 0;
 
    }
}