Java基础

Java帝国的诞生

• 1972年c诞生

  • 贴近硬件，运行极快，效率极高
  • 操作系统，编译器，数据库，网络系统等
  • 指针和内存管理 指针：没有给越界检查，轻易犯错。内存：自己分配空间，自己释放。
  • 时间浪费掉在指针和内存分配上！

• 1982年c++诞生

  • 面向对象
  • 兼容c
  • 图形领域，游戏等

• 急需建立一个新语言

  • 语法优点像c
  • 没有指针
  • 没有内存管理
  • 真正的可移植性 # java虚拟机jvm
  • 面向对象
  • 类型安全
  • 高质量类库
  • …

• Java面世——原名oak 现在叫Java
  

• 1995年的网页简单而粗糙 缺乏互动性

• 图形界面的程（Applet）

• Bill Gates 这是迄今为止设计的最好的语言！

• Java 2 标准版（J2SE）去占领桌面

• Java 2 移动版（J2ME）去占领手机

• Java 2 企业端（J2EE）去占领服务器

• 大量的巨头加入

Java发展

• 很多商业巨头纷纷加入：
  • 三高： 高可用 高性能 高并发
  • 他们基于Java开发了巨多的平台，系统，工具
  • 构建工具：Ant Maven Jekins
  • 应用服务器：Tomcat，Jetty，Jboss，Websphere，weblogic
  • Web开发：Struts，Spring，Hibernate，myBatis
  • 开发工具：Eclipse，Netbean，intellij idea，Jbuilder
  • 2006 Hadoop（大数据领域）
  • 2008 Android （手机端）

JAVA特性和优势

• 简单性（简单易学，免费使用）
• 面向对象
• 可以移植性 ——Write Once, Run Anywher！
• 高性能
• 分布式
• 动态性 反射机制，
• 多线程
• 安全性
• 健壮性

JAVA三大版本

Write Once, Run Anywhere——JVM（Java虚拟机，可以跨平台！）
JavaSE（Java Platform Standard Edition）：标准版（桌面程序，控制台开发…）
JavaME（Java Platform Micro Edition）：嵌入式开发（手机，小家电）现在基本死掉了
JavaEE（Java Platform Enterprise Edition）：企业版，企业级开发，（web端，服务器开发…）

JDK JRE JVM

JDK: Java Development Kit ｜Java 开发者工具：包括所有东西JRE、JVM等一些开发工具
JRE：Java Runtime Environment ｜Java 运行环境：包含Java虚拟机(JVM)、Applet
JVM：JAVA Virtual Machine | Java虚拟机

Hello Wolrd

1. 随便新建一个文件夹，用来存放代码：

2. 新建一个Java文件 ，文件后缀名为.java
   例：Hello.java

【注意点】：系统可能没有显示文件后缀名，我们需要手动打开

3. 编写程序

public class Hello{  // 定义一个类,类名是Hello要和文件名一样，我这里文件名是Hello.javapublic static void main(String[] args){  // 核心方法：主方法,程序通过main方法执行System.out.println("Hello,World!");    // 输出 Hello World！
}
}

4. 编译，命令行进入java文件目录下：javac java文件 ，会生成一个class文件（字节码文件）
5. 运行class文件：java class文件名（不要加后缀名）

javac Hello.java
java Hello

可能遇到的情况：

1. 每个单词的大小写不能出现问题 Java大小写敏感
2. 尽量使用英文
3. 文件名和类名，必须保证一致
4. 符号使用了中文。需要是英文

Java环境运行机制

• 编译型 (Compile)
  • 有一个负责编译的程序（编译器），把整个程序编译成机器语言让计算机使用
  • 速度很快，因此多用于操作系统
  • 必要时需要重新编译
  • 例如：操作系统 c语言
• 解释型
  • 执行一句，解释一句。
  • 效率不高，速度不要求
  • 例如：网页，服务器脚本对速度要求不高 ，如：js
  • 现在随着硬件技术的提高，解释型的效率也提高了，和编译型速度界限变得模糊了
• Java程序运行机制——先编译，后解释（.class文件才真正的去执行）
  

Java基本语法

创建 IntelliJ IDEA 项目

打开 IntelliJ IDEA 选择 New Project：

命名项目名，创建项目文件：（我这里创建的是一个空项目，之后加模块！）

等待加载完成：


创建模块：（这里再创建模块，用于区分各个不同的功能）

选择Java模块

命名模块：

配置Java环境:

编写代码，运行环境

创建class文件：

我这里创建的是：Hello.java

文件多的时候可以创建包：

写包名：

选中几个文件进行移动时：


编写代码：

public class Hello {public static void main(String[] args){System.out.println("Hello，World！");}
}

运行代码：

结果：
在设置里允许滑动滚轮调整字体大小：
Windows系统：File -> Setting -> Editor -> General -> Change font size with Command+Mouse Wheel in：
macOS: IntelliJ IDEA -> Preferences...-> Editor -> General -> Change font size with Command+Mouse Wheel in：

还可以配置字体颜色：（以注释举例）

注释

平时我们编写代码，代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要注释了。
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范

单行注释

// 这里是单行注释

多行注释 (快捷键：选中+Ctrl+/ 注释取消：选中+Ctrl+/)

/* 
多行注释，可以注释一段文字多行注释多行注释
*/

文档注释 （快捷键：/**+Enter）

/**
*@Description 这里是描述
*@Author 这里表明作者
*/

//有趣的代码注释
/****                    _ooOoo_*                   o8888888o*                   88" . "88*                   (| -_- |)*                    O\ = /O*                ____/`---'\____*              .   ' \\| |// `.*               / \\||| : |||// \*             / _||||| -:- |||||- \*               | | \\\ - /// | |*             | \_| ''\---/'' | |*              \ .-\__ `-` ___/-. /*           ___`. .' /--.--\ `. . __*        ."" '< `.___\_<|>_/___.' >'"".*       | | : `- \`.;`\ _ /`;.`/ - ` : | |*         \ \ `-. \_ __\ /__ _/ .-` / /* ======`-.____`-.___\_____/___.-`____.-'======*                    `=---='** .............................................*          佛祖保佑             永无BUG*/

标识符与关键字

Java 所有的组成部分都需要名字。类名，变量名以及方法名都被称为标识符

标识符注意点

• 所有的标识符，都应该以字母(A-Z或者a-z) 美元符($)或者下划线()开始
• 首字母之后 可以可以是字母，(A-Z 或者 a-z)，美元符（$)、下划线（_）或数字的任何字符组合
• 不能使用关键字作为变量名或方法名。
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value_、__1_value
• 非法标识符举例：123abc、-salary、#abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low。

数据类型

强类型语言

• 要求变量的使用要 严格符合规定，所有变量都必须 先定义 后才能使用。 因此安全性高，但是速度慢。

弱类型语言

• 要求变量的使用符合规定即可，所有变量都必须先定义后才能使用。 因此安全性高，但是速度慢。

public static void main(){String a = "hello";  //必须按数字类型定义int num = 10;System.out.println(a);System.out.println(num);
}

Java的数据类型，分为两大类

• 基本类型：（primitive type）
• 引用类型：（refreence type）

public class Demo2{//八大基本数据类型  快捷键查看类：command或ctrl + 点击//整数int num1 = 10; //最常用byte num2 = 20;short num3 = 30;long num4 = 30L; //long类型要在最后加L//浮点数 （小数）float num5 = 50.1F; //float类型要在数字最后加Fdouble num6 = 3.1415926;//字符类型char name = '中';//字符串，String不是关键字，是类//String name = "hello"//boolean 布尔值：是,非boolean flag = true;boolean flag2 = false;}

字节

• 位（bit）：是计算机内部数据储存的最小单位 ，11001100是一个 八位 二进制数

• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，

• 1B（byte，字节） = 8bit（位）

• 字符：是指计算机中使用的字母，数字，字和符号（例：'a'，'A'，'中'，'国'）

• 1bit 表示1位

• 1byte表示一个字节 1B = 8b

• 1024B = 1KB

• 1024KB = 1MB

• 1024MB = 1GB

• 1024GB = 1TB

拓展

public class Demo2 {public static void main(String[] args){//数据拓展 进制 二进制：0b开头  十进制  八进制：0开头  十六进制:0x开头int i = 10;int i2 = 010;  // 八进制：0开头   逢8进1int i3 = 0x10; // 十六进制:0x开头  逢16进1   0~9 A~FSystem.out.println(i);System.out.println(i2);System.out.println(i3);System.out.println("===================================");//==========================================//浮点数拓展  央行业务怎么表示float f = 0.1f;    //0.1double d = 1.0/10; //0.1System.out.println(f);System.out.println(d);System.out.println(f==d);float f1 = 212121212F;float f2 = f1 + 1;System.out.println(f1 == f2 );  //结果为：true 相同//原因：浮点数 float：是有限离散的，有舍入误差，其结果是个大约数，接近但是不等于//最好完全避免使用浮点数比较大小！//最好完全避免使用浮点数比较大小！//最好完全避免使用浮点数比较大小！//使用BigDecimal数学工具类进行银行业务System.out.println("===================================");//======================================//字符拓展char c1 = 'a';char c2 = '中';System.out.println(c1);System.out.println((int)c1); //强制转换System.out.println(c2);System.out.println((int)c2); //强制转换//所有的字符本质上还是数字//编码 Unicode ASCII码：a = 97,A = 65,占2字节 最多表示0～65536个字符   最早的Excel表格只有2的16次方，65536char c3 = '\u0061'; //定义一个Unicode编码System.out.println(c3); //aSystem.out.println("===================================");//转义字符// \t 制表符 tab空格// \n 换行符//......System.out.println("Hello\nWorld");System.out.println("===================================");//对象 从内存分析String sa = new String("hello world");String sb = new String("hello world");System.out.println(sa == sb); //内存存储原因：falseString sc = "hello world";String sd = "hello world";System.out.println(sc == sd);//内存存储：trueSystem.out.println("===================================");//布尔值扩展boolean flag = true;//代码要精简易读 Less is More!if(flag == true){};//新手if (flag){};//老手}
}

类型转换

• 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

低 -----------------------------------------> 高 （小数优先级大于整数）
byte,short,char -> int -> long -> float -> double

• 运算中，不同类型的数据转化为同一类型，然后进行运算。
  • 强制类型转换
  • 自动类型转换

public class Demo3 {public static void main(String[] args){int i = 128;  //强制转换   (类型)变量名   高 -> 低byte b = (byte)i; //内存溢出    System.out.println(i); // 128System.out.println(b); //-128 //自动转换   低 -> 高double d = i}
}

byte范围是：-128～127

public class Demo3 {public static void main(String[] args){int i = 128;//强制转换 (类型)变量名 高 -> 低byte b = (byte)i;  //内存溢出System.out.println(i);//128System.out.println(b);//-128//自动转换   低 -> 高double d = i;System.out.println(i);//128System.out.println(d);//128.0System.out.println("=========================");//精度问题System.out.println("23.7强制转换int类型："+(int)23.7);//23System.out.println("-45.98f强制转换int类型："+(int)-45.89f);//-45System.out.println("=========================");char c = 'a';int e = c+1; //低到高，自动转换System.out.println(e); //98System.out.println((char)e);// 转换回char类型，高到低，强制转换 //b/*注意点：1. 不能对boolean值进行转换2. 不能把类型转换为不相干的类型3. 在把高容量转换为低容量的时候，强制转换，反之自动转换4. 转换的时候可能存在内存溢出或者精度问题。*/System.out.println("=========================");//操作比较大的数的时候，注意溢出问题//JDK7 新特性，数字之间可以使用下划线分割int money = 10_0000_0000; // 不会输出下划线 _System.out.println(money);//1000000000int years = 20;int total = money*years; //计算的时候溢出了System.out.println(total); //-1474836480double total2 = money*years; //默认是int类型，转换之前已经出现问题了，因此就是把结果转换成longSystem.out.println(total2);long total3 = money*((long)years);//先把一个数转换成longSystem.out.println(total3);//因为long L 和 l 都可以 但是l容易看成1，所以建议都使用L}
}

变量

• 变量是什么：就是可以变化的量！（代表一个空间，空间里面存储的值是可以变化的。）
• Java是一种强类型语言，每个变量都必须声明其类型。
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName  [=value] [{,varName[=value]}];// 数据类型 变量名 = 值; //可以使用逗号隔开来声明多个同类型变量(不建议用)。

• 注意事项：
  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  • 变量名必须是合法的标识符。
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

public class Demo4 {public static void main(String[] args){//int  a,b,c; //不建议//程序的 可读性int a = 1;int b = 2;int c = 3;String name = "name";char x = 'X';double p1 = 3.14;}
}

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Demo5 {// 常量//public private final static 修饰符 不存在先后顺序static final double PI = 3.14;final static double PI2 = 3.14;//属性：变量// 类变量 static  与类一起出现，一起消失！static double salary = 2500;//实例变量：从属于对象，在方法外面定义//如果不自行初始化，这个类型的默认值：0，0.0, null(u0000)// 布尔值 boolean默认：false// 除了基本类型，其余的默认值都是nullString str ; //实例变量int age;static int allClicks = 0;  // 类变量  static 静态的//main方法：主程序方法public static void main(String[] args){//常量System.out.println(PI);System.out.println(PI2);//局部变量 是在方法里：{}里 ：必须声明和初始化值int i = 10;//使用实例变量：变量名字 == new Demo5();//变量类型 Demo5Demo5 demo5 = new Demo5(); //建立对象System.out.println(demo5.age); //没有默认初始值，初始值为0System.out.println(demo5.str); //没有默认初始值，默认值 null//类变量 staticSystem.out.println(salary);//可以直接输出}//其他方法public void method(){int i = 0; //局部变量}}

常量

• 常量（Constant）:初始化（initialize）后不能再改变值！不会变动的值。
• 所有常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
• 常量名一般使用大写字符！

变量的命名规范

• 所有变量：方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary (除了第一个单词，后面的单词首字母大写 lastName)
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run()，runRun()

运算符

• Java 语言支持如下运算符：
  • 算术运算符：+、-、*、/、%（取余）、++、--
  • 赋值运算符：=
  • 关系运算符：>、<、>=、<=、==（等于）、!=（不等于）、instanceof
  • 逻辑运算符：&&（与）、||（或）、！（非）
  • 位运算符：&、｜、^、~、>>、<<、>>>（了解即可）
  • 条件运算符：？、：
  • 扩展赋值运算符：+=、-=、*=、/=

package operator;/*** 计算*/
public class Demo1 {public static void main(String[] args){//二元运算符// Ctrl + D  复制当前行到下一行int a = 10;int b = 20;int c = 25;int d = 25;System.out.println(a+b);System.out.println(a-b);System.out.println(a*b);System.out.println(a/b);// 0.5 不是int类型 四舍五入 需要强转 a/(double)bSystem.out.println("=====================");long l1 = 1212121212;int i = 123;short s = 10;byte dd = 8;System.out.println(l1+i+s+dd); //long 只要存在long类型，结果也为long类型System.out.println(i+s+dd); //int 没有long类型，结果都为intSystem.out.println(s+dd);// intSystem.out.println((double)s+dd);//double 类型  只要存在double类型，结果也为double类型System.out.println("=====================");//关系运算符的结果：布尔值 正确 错误//多和if 一起用int a1 = 10;int a2 = 20;System.out.println(a>b);//falseSystem.out.println(a<b);//trueSystem.out.println(a==b);//falseSystem.out.println(a!=b);//trueSystem.out.println("=====================");//取余 模运算int a3 = 21;System.out.println(a3%a1); // c/a =  21/10 = 2.......1System.out.println("=====================");//++ 自增 -- 自减 一元运算符int f = 3;int g = f++; // 执行完这个代码后，先给g赋值，再自增// f = f + 1  执行完System.out.println("f="+f);// 4System.out.println("g="+g);// 3 先给g赋值，再自增System.out.println("f="+f);// 4System.out.println("+++++++++++++++");f = 3;int h = ++f; // 执行完这个代码前，先再自增，再给h赋值// f = f + 1  执行完System.out.println("f="+f);// 4System.out.println("h="+h);// 4 先再自增，再给h赋值System.out.println("f="+f);// 4System.out.println(f);// 4System.out.println(g);// 3System.out.println(h);// 4System.out.println("=====================");// 幂运算  使用工具类来操作double pow = Math.pow(2,3);// 2^3 = 2*2*2 = 8System.out.println(pow);}
}

package operator;/*** 逻辑运算*/
public class Demo2 {public static  void main(String[] args){// 与（and） 或（or） 非（取反）boolean a = true;boolean b = false;System.out.println("a && b ="+(a && b)); //逻辑与运算：两个变量都为真，结果才为真trueSystem.out.println("a || b ="+(a || b)); //逻辑或运算：两个变量有一个为真，结果为真trueSystem.out.println("!(a && b) ="+(!(a && b)));//逻辑非运算：如果是真即为假，如果为假即为真//短路运算int c = 5;boolean d = (c < 4)&&(c++<4);System.out.println(d);System.out.println(c);// 5 因为(c < 4)&&(c++<4)中(c < 4)已经为false，因此不会再计算(c++<4) c依旧为5//位运算/*与运算：0与0 = 0   0与1，1与0 = 0  1与1 = 1或运算：0或0 = 0   0或1，1或0 = 1  1或1 = 1异或运算：相同即为0 不同即为1取反：0取1 1取0 取反A = 0011 1100B = 0000 1101----------------------A&B  0000 1100A|B  0011 1101A^B  0011 0001~B   1111 0010*//*//面试题：2*8 如何计算最块?2*8 = 16 2*2*2*2 位运算<< 左移>> 右移*/System.out.println("====================");/*0000 0000  00000 0001  10000 0010  20000 0011  30000 0100  40000 1000  80001 0000  16位运算效率极高<<  *2>>  /2*/System.out.println(2<<3);System.out.println("====================");//int x = 10;int y = 20;x+= y; //x = x+ySystem.out.println(x);x = 10;y = 20;x-= y; //x = x-ySystem.out.println(x);System.out.println("====================");x = 10;y = 20;//字符串链接符  +System.out.println("——"+ x + y);// ——1020 只要+两侧有一侧是String类型，System.out.println(x + y +"——");// 30——  如果先+是数，则先计算后String拼接System.out.println("====================");//三元运算符  ？ ：// x ? y : z//如果x==true，则结果为y，否则结果为zint score = 80;String type1 = score < 60 ? "不及格": "及格";System.out.println(type1);//及格score = 50;String type2 = score < 60 ? "不及格": "及格";System.out.println(type2);//不及格}}

运算符优先级

包机制 (文件夹)

• 为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。
• 包语句的语法格式为：
  package pkg1[.pkg2[.pkg3...]];
• 一般利用公司域名倒置作为包名 ：com.test.blog.www
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可完成此功能
  import package1[.package2...].(classname|*);

改变一下以上项目的存储方式：

// 定义包：写在所有代码的最前面
// 查看包：command/Ctrl + 点击 
package com.learn.base;
package com.learn.operator;//导入包
//自动生成包，快捷键macOS：option+shift+Enter  Windows: Alt+Enter
import com.learn.base.Demo1 //必须在package...下面
import com.learn.* //.*通配符，导入包下所有的类

JavaDoc

Java官方文档

Jdk8官方文档

• Javadoc命令是用来生成自己的API文档的
• 参数信息：
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 一场抛出情况

生成自己的API文档

先写好自己的注释

package com.learn.base;/*** @author name * @version 1.0    * @since 1.8   */
public class doc {String name;/*** * @param name        //参数* @return            //返回值* @throws Exception  //异常*/public String test(String name) throws Exception{return name;}//通过命令行生成文档： javadoc 参数 java文件
}

自动生成文档：
可以在要生成文档的的文件夹下打开命令行：(在当前doc文件下)

# encoding 编码  chartset 字符集编码 可显示中文
javadoc -encoding UTF-8 -charset UTF-8 doc.java

cmd代码：

代码运行后会生成很多文件：关注index.html

文档内容：

来源：狂神说

狂神说