做一个只懂技术的程序员是远远不够的，了解技术的发展更新迭代也很重要
这就是java的logo：一杯美味的咖啡
上个世纪90年代，消费类电子产品越来越受人追捧，为了提升消费类电子产品的智能化程度。Sun公司为了抢占市场先机，在1991年成立了一个称为Green的项目小组，专攻计算机在家电产品上的嵌入式应用。由于可以用的资源极其有限。很多成员发现C++太复杂以至很多开发者经常错误使用。而且C++缺少垃圾回收系统，还有可移植的安全性、分布程序设计、和多线程功能。为了解决这个麻烦的问题，他们决定开发出一种新的语言 他就是java的前身：
—— Oka（橡树）
对，java的前身就是Oka。之所以起Oka这个名字，是因为团队对这门语言的首先期望就是健壮，而当时团队的办公室外刚好有一颗橡树，高大，健壮。受此启发，Oka就被用作Java语言的第一个名字，寓意着这是一门简单、健壮的语言。
而后来因为版权的问题，Oka不得不改名，但关于改成什么，大家并没有灵感，直到有一天团队的几个主要成员在一起喝咖啡，正品尝一种来自爪哇岛（Java）的咖啡。此时，其中的一个工程师突然想到，他们之所以要创建一门新语言，在很大程度上，就是期望把程序员从工程的泥潭中拯救出来，从而让大家有闲暇的时间来品一杯美味的咖啡。于是Oka就被改名为Java，寓意着程序员如果用Java开发，从此之后能过上从容、惬意的生活(不是)。
此时不卷，更待何时？
一入编程深似海，学习编程，难免会觉得枯燥无味。尽管大多时候，我们都在被各种程序Bug困扰，像是在编程世界里升级打怪，在看不到尽头的变成世界里做一个苦行僧，但是，当我们真正的用学到的东西创造出价值后，会觉得这些枯燥是值得的。我们一起努力，慢慢品尝Java这杯浓烈的咖啡！
java发展至今，积累了一套完整的生态，目前为止任然是中国最活跃的编程语言之一：
现在的csdn，bilibili，github，gitee上面都能找到完整的，有体系的java学习资料，可以帮助你一路梭哈完javaSE，java框架等java相关的技术栈。
还有学习阶段几乎你遇到的所有的bug，你都能在java有关的学习网站找到对应的解答
java拥有强大的框架，java有许多的框架如spring ，springboot，springmvc,这些框架帮助它在web方面表现得十分优异
Java中有一个名言，叫做一次编译，处处运行。java内置的虚拟机可以让你在windows上面写的程序，经过虚拟机编译后直接在linux，unix等操作系统下直接运行。比起c++这些需要考虑不同操作系统兼容的编程语言，Java就方便了许多
用我自己的理解，面向对象就是先制定一个统一的模板，当我要的时候，就新建（new）一个
现实生活你我能找不到对象（不是)，但在java的世界里，得到一个对象实在不要太简单，new一个就好了 !
大概像这样：
Boy boy=new Boy("唱","跳","rap","打篮球")
/*
BoyFriend:这就是我定义的模板
boyFriend：他代表你新建的这个对象的名字，因为我们可以创建太多的对象，如果不取个名字，就会很不好管理
new BoyFriend("唱","跳","rap","打篮球")，这就是我在新建对象的时候，赋予这个完美的男人的特征：唱跳rap打篮球，
*/这样面向对象的可以省去很多像c这样纯面向过程的繁琐的代码，让我们更加注重业务逻辑，而不是代码本身
java内置了一个像成龙一样的专业丢垃圾助理，像c++创建的对象，需要我们手动去释放，但java就不用，使得我们又省去了许多繁琐的代码。一句话就是：你创建的对象，尽管去用，不用了会有人来兜底
Java 语言在伪编译时，做了许多早期潜在问题的检查，并且在运行时又做了一些相应的检查，可以说是一种最严格的 “编译器”。 它的这种“防患于未然”的手段将许多程序申的错误扼杀在摇篮之中。经常有许多在其他语言中必须通过运行才会暴露出来的错误，在编译阶段就被发现了。 另外，在Java 语言中还具备了许多保证程序稳定、健壮的特性，有效地滅少了错误，也使得Java 应用程序更加健壮
线程，是一种轻量级进程，是现代程序设计中必不可少的一种特性。多线程处理能力使得程序能够具有更好的交互性、实时性。 Java 在多线程处理方面性能超群，具有让设计者惊喜的强大功能，而且在 Java 语言中进行多线程处理很简单。
由于 Java 语言在设计时，在安全性方面考虑很仔细，做了许多探究，使得 Java 语言成为目前最安全的一种程序设计语言。
java还有很多优秀的理念（继承，封装，多态......），在今后的学习中，我们再去慢慢挖掘！
我最开始学java的时候，这些专业名词总是弄不明白,所以我把这些罗列出来。让你们有个印象，以后也不至于这么陌生:
## SDK:
**SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等**。
## JRE:
##JRE顾名思义是java运行时环境，包含了java虚拟机(jvm)，java基础类库。是使用java语言编写的程序运行所需要的软件环境，是提供给想运行java程序的用户使用的。
## JVM:JVM是Java Virtual Machine的缩写
**JVM是编译java代码的虚构计算机，jvm使得Java语言在不同平台上运行时不需要重新编译。Java语言使用Jvm虚拟机屏蔽了与具体平台相关的信息，使得Java语言生成在Java虚拟机上运行的目标代码，就可以在多种平台上不加修改地运行。**
## JDK：
**是java开发工具包，是程序员使用java语言编写java程序所需的开发工具包，是提供给程序员使用的。JDK包含了JRE.简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。****
## Jar:
**开发人员写好的.java文件打包编译就会生成jar包，里面包含了我们写好的源码**
每一个程序员都是通过这个朴实无华分hello world程序进入编程的大门，今天我们就从这几行代码开始了解java的基础入门
public class Test
{
public static void main(String[] args)
{
System.out.println("(♥◠‿◠)ﾉﾞ hello world! ლ(´ڡ`ლ)ﾞ \n" +
" .-------. ____ __ \n" +
" | _ _ \\ \\ \\ / / \n" +
" | ( ' ) | \\ _. / ' \n" +
" |(_ o _) / _( )_ .' \n" +
" | (_,_).' __ ___(_ o _)' \n" +
" | |\\ \\ | || |(_,_)' \n" +
" | | \\ `' /| `-' / \n" +
" | | \\ / \\ / \n" +
" ''-' `'-' `-..-' ");
}
}
在Java中，main方法是一个程序的入口，我们可以在java程序中定义很多方法，但是程序只能从main方法中进入。它被声明为公有静态方法，参数是一个字符串数组，返回值为void类型。一个java文件可以有无数个main方法，但是一个类中只能有一个main方法，当想要运行不同的main时，可以在左上角的白色小箭头处选择要运行的main方法，然后点击右边的绿色箭头即可运行。
| 运算符 | 说明 |
|---|---|
| == | 判断是否相等，返回bool值 |
| = | 赋值，右边赋值给左边 |
| 后++ | 后置自增，先赋值再自增 |
| 后-- | 后置自减，先赋值再自减 |
| 前++ | 前置自增，先自增，再赋值 |
| 前-- | 前置自减，先自减，再赋值 |
| -= | 做差并赋值 |
| += | 做和并赋值 |
我们只是在程序中定义好了变量，是完全不够用的，或许，我们可以拿他们来加减乘除
int a = 1;
short b = 2;
int c = a + b;
int d=a*b;
//强制类型转换
int e=(double)a/b
//c=3;d=2;e=0.5
-
两个整数A、B做取余操作，例：A%B
-
如果A>B,取余结果按照小学学过的数学公式计算
-
如果A<B,取余结果等于A
-
public static void main(String[] args) { int a = 8, b = 33; int c = 21, d = 65; int e = 43, f = 117; System.out.println(a % b); System.out.println(c % d); System.out.println(e % f); } //输出结果 //8 //21 //43
当然，java中还有一些我们不常用的运算符，他们直接操作二进制码，会让效率更快，比如说：
^(无进制加,异或运算)；
000011^000011=0;
也就是3^3=0;|=*(位或运算符)
使用规则：两个二进制操作数对应位只要有一个为1 结果位 就为1，其余情况为0；
整数 b = 127 0111 1111
整数 c = 128 1000 0000
(b | c)= 1111 1111&= (位与运算符)；
使用规则：两个二进制操作数对应位同为1 结果位 才为1，其余情况为0；
15 的二进制位： 0000 1111
127 的二进制为：0111 1111
所以，15&127= 0000 1111~= (位非运算符)
就是对应的二进制码全部取反，比如说000001
取反之后就是：111110
//由于符号位变化，会变成负数还有位移运算：>> , << , >>>**:
（无符号右移运算符在右移的时候是补0的，而右移运算符是补符号位的。）
那如果我们想要在特定的情况下进行不同的逻辑操作呢？
这里就要引入 if else基础语句了,:
if ,else if都是表示根据条件进入不同的分支
else表示所有的与上述条件不满足的所有情况都会走到这里来
举个栗子
int a = 0;
if (a == 0) {
a = 10;
} else if (a == 1) {
System.out.println("芝士雪豹");
} else if (a == 10) {
System.out.println("电子烟");
} else {
System.out.println("雪豹闭嘴");
}和if-else有异曲同工之出的还有switch-case语句
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
default:
语句体n+1;
}执行流程：
首先计算表达式中的值，然后和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break结束语句，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束。
switch中的表达式注意事项
1、swtich 表达式支持的类型可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。
2、在JDK5之后的自动拆箱，对应的这四种基础类型的封装类也同样支持Byte,Short,Character,Integer
3、case的穿透性 ：在switch语句中，如果后面不写break，程序会一直往下走，不会判断case中的常量值，执行后面所有的case知道遇到break结束，或者执行完所有的case结束
如果你特别喜欢电子烟，想让java输出十次电子烟，但是又不想连续输入十次sout,那怎么办呢？
for(int a=0;a<10;a++){//a++表示a+1
System.out.println("电子烟");
}
/*
**一个完整的for'循环，需要三个要素**
1：变量的初始值
2：循环的结束条件
3：变量的更改原则
*/初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}如果while表达式里面的值为true，就会执行花括号里面的语句
ej:
int i = 0; // 初始化语句：与for循环同理
while(i < 3) { // 循环条件是 i < 3，循环到i >= 3时，将结束循环
System.out.println("Hello World"); // 循环体语句：被重复执行的代码
i++; // 迭代语句，循环结构不可或缺的，如果忘记写迭代语句了，将会进入死循环现象
}do {
循环体语句;
控制条件语句;
}while(判断条件语句);ej:
int sum = 0; //定义变量sum,用于存储求和的值
int i = 1; //定义变量i
do { // do 就是 干
//System.out.println("i = " + i); //循环体语句
sum +=i;
i++;
}
while (i <= 100); //判断条件语句
System.out.println("sum = "+sum); //输出结果
//5050b ? x : yb为真的话就返回x,反之返回y
int a=10;
int b=9;
int c;
c= (a>b) ? a:c
//返回结果，a>b,为true,返回10，c=10
不知道你们有没有注意到，刚才定义的hello world程序里，main方法传入了一个参数String[] args
其实这就是一个String数组。
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组是Java编程中常用的一种数据类型，java中很多源码都用到了数组
数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[数组长度];
数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];
ej:
int[] arr = new int[3];
int arr[] = new int[3];
//**这里只是声明了长度为三的数组，我们并没有为它们赋值**
//赋值，指定下标
arr[0]=9;在声明创建数组的时候就为数组赋值
int[] arr = new int[]{1,2,3,4,5};
// 可以拆分
int[] arr;
arr = new int[]{1,2,3,4,5};这里只是以int为例，java中的数据类型都是可以有数组的，如Object[],String[]，Char[]……
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ] 数组名 = new 数据类型[m][n]
数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]
//定义一个三行两列的数组
int [][] arr = new arr[3][2];数据类型 [ ][ ] 数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};java中的返回值可以是基本数据类型，也可以是引用数据类型
//Java内置了八种基本数据类型
//基本数据类型--四类八种：整数类（byte、short、int、long）、浮点类（float、double）、字符类（char）、布尔型（boolean）；
//除此之外即为引用类数据类型（上文中我们创建的对象）。
int a = 1;//四个字节，范围
short b = 1;//使用两个字节存储，范围为-32768~32767；
long c = 1;//八个字节，-2^64，2^64-1
double d = 1.7d;//使用8字节存储，精度是float的2倍，绝大部分应用程序采用float类型。
float e = 1.6f;//使用4字节存储，精度可以精确到小数点后7位有效数字，在多数情况下，float类型精度很难满足需要。
//①默认浮点类型为double；②使用float的时候，数字后面要添加f;
byte h = 127;使用1个字节存储，范围为-128~127；
boolean f = true;//布尔型--boolean--只有true和false两个值，存储时占1位。
char g = 'x';//字符类--char--占用2个字节，使用时用''单引号表示；'A';表示一个字符，"A"表示一个字符串，即一个字符序列| 数据类型 | 说明 |
|---|---|
| byte | 占用一个字节，范围是-2^7 |
| short | 占用两个字节，范围是-2^15 |
| int | 占用四个字节，范围是-2^31~2^31-1，2147483647,-2147483648 |
| long | 占用八个字节，范围是-2^63~2^63-1， |
| 数据类型 | 说明 |
|---|---|
| float | 4字节 大约±3.402 823 47E+38F （有效位数为6~7位），没有后缀F的浮点数值（如3.14）默认为double类型，当然，也可以在浮点数值后面添加后缀D或的（例如，3.14D）。 |
| double | 8字节 大约±1.797 693 134 862 315 70E+308（有效位数为15位）。double表示这种类型的数值精度是float类型的两倍（有人称之为双精度数值）。绝大部分应用程序都采用double类型。在很多情况下，float类型的精度很难满足需求 |
| 数据类型 | 说明 |
|---|---|
| char | 2字节，16位。char在java中是16位，用于存放单个字符。用单引号【' '】括住，'A';表示一个字符，"A"表示一个字符串，即一个字符序列 |
| 数据类型 | 说明 |
|---|---|
| boolean | 变量存储为1 个字节，只能是 True 或是 False |
java中的引用数据类型可以理解为你所创建的对象
Boy boy=new Boy("唱","跳","rap","打篮球");
Scanner sca=new Scanner(System.in);boy就是我们java里的引用数据类型，也可以理解为除Java中的基本数据类型，你所定义的Class都可以作为返回类型
重要（强制类型转换）：
在java程序中，一定要注意返回数据类型的准确，基本数据类型在做强制类型转换时，占字节数小的可以转换成更大的数据类型，如short可以转换成int，反过来就不可以。引用数据类型也是相同的道理
包装类： Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类，包装类均位于java.lang包。
自动装箱和自动拆箱
| 自动装箱 | 就是将基本数据类型自动转换成对应的包装类。Integer a=127； |
|---|---|
| 自动拆箱： | 就是将包装类自动转换成对应的基本数据类型。int b=a.intValue(); |
聪明的你一定看到了main方法里面还有一个static修饰符：
1：static是静态意思，可以修饰成员变量和成员方法;static修饰成员变量表示该成员变量在内存中只存储一份，可以被共享访问，修改。
2：static修饰的成员属性，成员方法，不属于任何一个对象，它属于一个类模板公用，我们调用它时，直接使用类名加 "."就可以直接访问了
final意味着不可变：不可变的是变量的引用而非引用指向对象的内容（String）
1、被final修饰的类不可以被继承
2、被final修饰的方法不可以被重写
3：被final修饰的变量不可以被改变
4：final修饰的变量往往和static搭配
这是java用来输出文字的特定语法，他的实现有点复杂，简单来说讲就是System类里面有的成员属性：一个用final修饰的PrintStream流的对象out，再调用它的println方法，现在只需要会用就行，感兴趣的可以去了解了解
这个需要在编程之中慢慢理解，我们先了解一下:
类是一个java程序中必不可少的声明，我们每创建一个普通的.java文件，就要声明一个类名，注意声明类要使用驼峰命名法；
一个类是某些抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）
是一类东西的统一模板；比如说人类:我们一提到人类，就会想到人都有的东西。在java中也是同样的设计思想
比如说我定义一个Person类
//我根据人类都可以有名字，年龄，性别，抽象出了拥有这三个属性的模板，这个模板就叫做类
class Person{
//成员属性
String name;
int age;
boolean sex;
//成员方法
public void eat(){
System.out.println("人在吃东西");
}
}继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，属性等，或子类从父类继承方法，使得子类具有父类相同的行为。
通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
class teacher{ //声明一个teacher类为父类
String name; //定义父类的成员变量name、age
int age;
void show(){ //定义父类成员方法，将成员变量输出
System.out.println(name);
System.out.println(age);
}
}
class Student extends teacher { //声明一个Student类为子类并继承父类
}
public class myfirst {
public static void main(String[] args) {
System.out.println("学生");
Student student=new Student(); //声明一个Student类的实例对象student
student.name="Tom"; //子类调用父类的成员变量name并赋值
student.age=19; //子类调用父类的成员变量age并赋值
student.show(); //子类调用父类的成员方法show
}
}区别于方法重载，方法重载一定是出现在不同的类中，且类之间存在继承关系，在java中，所有的类都默认继承了Object类
常见的重写toString()方法（常见的面试题）
1：java中所有的类都直接或间接继承了Object类，从而继承了Object类的toString()方法
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}2：Object类的toString()方法返回的是当前对象的内存地址，并没有返回我们想要的东西 这个时候我们就要重写toString()方法了
public class Animal {
String str ;
@Override
public String toString() {
return "Animal{" +
"str='" + str + '\'' +
'}';
}
}继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用； 在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法； 可以在子类中声明一个在父类中没有的新字段和方法； 可以在子类中编写一个父类当中具有相同名的新实例方法，这称为“方法重写”或“方法覆盖”； 可以在子类中编写一个调用父类构造方法的子类构造方法，既可以隐式地实现，也可以通过使用关键字super来实现。
作用:在java中限定各程序的访问范围
上图！：
- 1.它可以用来修饰类，但它修饰类的时候文件名必须与类名一致
- 2.因为它的范围最大，所以在很多位置都有可能造成它内容的修改，所以不推荐使用
- 3.在子类继承的时候，它修饰的成员都可以被继承
-
不可以用来修饰类
-
protect和public差不多，唯一不同的是protected修饰的属性在其他的java包里，只有他的子类可以访问
- default就是不适用修饰符，默认为同一包中的自己和其子类可以访问
1.不可以使用它来修饰类
2.它修饰的成员变量只能通过，特定的方法来使用
3.在继承中，它修饰的成员不能被继承
是不是感觉很难理解？其实我当初也是这么觉得的，甚至这些差点把我劝退,从我写了一年的java实战来看，用的最多的也就是public，和private这两个修饰符，其他的我们会在不断地写代码的程序中慢慢了解到的
面向对象进阶，深入了解继承，封装，多态
this关键字的使用，区别于super关键字
了解Java的基本包装类，以及为什么java要使用包装类
2:预习完后，试着解释下面的输出结果
String str="123";
String str1="123";
String str2=new String("123");
System.out.println(str==str1);
System.out.println(str==str2);来点算法：两数之和
回文数：