倡议看完目录后扔进收藏夹吃灰，须要用的时候再翻出来。（手动狗头）

本文次要包含Java入门的一些常识，包含JDK环境装置，罕用语法以及面向对象编程等。

【目录构造】

Java根底1，Java语言的特点2，配置开发环境3，经典HelloWorld3.1 命令行运行Java程序3.2 应用IDEA 运行Java程序4，数据类型&变量4.1 为什么要设计不同品种的数据类型？4.2 数据变量&类型的定义4.3 根本数据类型4.4 主动类型转换&强制类型转换4.5 包装类面向对象1，灵魂拷问，什么是面向对象？2，如何实现面向对象？——封装，继承，多态2.1 封装2.2 继承2.3 多态3，关键字盘点3.1 static3.2 final

Java根底

1，Java语言的特点

• 基于JVM的跨平台语言
• 具备垃圾回收机制
• 生态弱小

2，配置开发环境

JDK版本多样，次要包含Oracle JDK 和OpenJDK

反对国产的话能够思考阿里的dragonwell：https://cn.aliyun.com/product/dragonwell

【win10装置JDK的罕用步骤】

• jdk8下载地址：

https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

【下载的这个安装包次要蕴含JDK，JRE，JavaFx包】（JavaFX次要用于桌面端开发）

• 设置jdk装置门路

• 设置jre装置门路

• 设置环境变量

  • 找到jdk装置的bin目录，复制装置门路

![1566378270545](https://img2020.cnblogs.com/blog/1401585/202007/1401585-20200714114815730-1502938281.png)*   右键电脑抉择属性        ![1566378337808](https://img2020.cnblogs.com/blog/1401585/202007/1401585-20200714114815475-1056133413.png)    

增加刚刚复制的门路到path里：

点击三个确定。

• 查看是否装置胜利

  java -version

  java

  javac

3，经典HelloWorld

3.1 命令行运行Java程序

• 新建文件，命名为HelloWorld.java

  用记事本关上，输出

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

• 关上命令行，定位到HelloWorld.java所在位置

  javac HelloWorld.java     //编译

  java HelloWorld     //运行

3.2 应用IDEA 运行Java程序

• 装置IDEA

  https://www.jetbrains.com/idea/

• 配置JDK

• 创立Java程序

• 输入HelloWorld

package com.company;

public class Main {

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

• 运行程序

4，数据类型&变量

4.1 为什么要设计不同品种的数据类型？

以后果为导向来剖析：Java的整数类型分为4种：byte，short，int，long。四种的区别在于占用的存储空间不一样。

byte占用1个字节，short占用2个字节，int占用4个字节，而long占用8个字节。

1字节等于8位而八位能够示意数-128 - 127。这是byte类型的示意范畴。那如果想用计算机计算1000加上1000，byte显著是不可用的。因为byte示意不了1000这个数值。

而short类型的存储空间为2个字节，也就是16位。对于short数据类型来说，能示意多大的数呢？依据8位的示意范畴推算：

-2^15 = 2^15-1   -32768--32767

以此类推，int为4个字节，long为8个字节，能示意的数更大。

Java通过定义变量的类型来规定变量的内存空间大小，通过阶梯式的定义，既有满足小数值运行的byte类型，也有反对大数值运算的long类型。这样不仅满足运算的最大反对（long），同时也能节俭零碎内存资源（byte）。

【总结】

数据类型的辨别是一种零碎资源分配优化的计划。

【字节和位的关系】

字节是一种存储单位的度量。1个字节等于8位。

位能够了解为计算机的最小单位：0或者是1。也就是是说1个字节是8个0和1的排列组合：

比如说：00000000,00000001,00000011,......11111111。

【实践上1个字节能够示意多大的数呢？】

• 在无符号位的状况下：

  00000000转换为十进制仍然是0,11111111转换为十进制是255。

  转换工具：https://tool.lu/hexconvert/

  也就是说，一个字节最大能够示意255而最小1能够示意0。

• 在有符号位的状况下：

  如果8位示意负数和正数，那么8位能够示意的范畴是多大呢？

  通常状况下，用第一位来示意正负【0为正，1为负】，这样算下来8位能够示意的范畴是-127到+127。

【实际上1个字节能够示意多大的数呢？补码退场】

上述引入符号位的8位二进制数能够了解为原码。对于负数来说，原码就是补码，而对于正数来说，符号位不变，其余原码按位取反加1所得即为补码。

为什么须要补码？

补码的呈现使得加减法只有加法，简化了计算构造，进步运算速度。（减法变成了加一个正数）

【为什么8位二进制数补码示意的范畴是-128-127？】

无符号位原码：0000 0000 - 1111 1111 示意范畴0 - 255

有符号位原码：1111 1111 - 0111 1111 示意范畴-127 - 127

补码：符号位不变，在原码的根底上按位取反加1，实践上最大的数0111 1111 = 127 ，最小的数 1111 1111 = -127

然而非凡状况：原码0000 0000 实践上示意负数，也就是+0，原码1000 0000实践上示意正数，变为补码后去掉最高为也是0000 0000。

[+0]原码=0000 0000， [-0]原码=1000 0000
[+0]反码=0000 0000， [-0]反码=1111 1111
[+0]补码=0000 0000， [-0]补码=0000 0000

+0的补码和-0的补码都是0000 0000。但8位二进制数的补码能够示意2^8也就是256个数1-127，-1-（-127）一共数254个数。

所以计算机将补码-0（1000 000）非凡设为-128。这个数没有原码和反码。

（就是多了一个示意的数，计算机就非凡解决了）

4.2 数据变量&类型的定义

变量是内存中的一个存储区域。而数据类型的定义决定了这块存储区域的大小。

比方 int x ；其中x变量在内存中占有肯定空间，而int决定这个空间是4个字节。

【对于变量的形容】

• 变量是内存中的一个存储区域。【程序运行的时候，变量是放在内存里的】
• 存储区域的数据能够在同一类型范畴里一直变动【所以叫变量，就是能变嘛】
• 变量包含：例如【int x = 3】 变量类型int 变量名x 变量的值3
• 变量必须先申明后应用

  int x = 10; (√)

  x = 10; (×)

  申明：变量必须得先指定具体的数据类型能力应用。

4.3 根本数据类型

4类8种：4种整数型，2种浮点型，1种字符型，一种布尔型

byte

1字节

默认值

short

2字节

0

int

4字节

0

long

8字节

0L

float

4字节

0f

double

8字节

0d

char

2字节

‘u000’

boolean

4字节

false

4.4 主动类型转换&强制类型转换

主动类型转换：由示意范畴小的主动转换为示意范畴大的。

强制类型转换：反向转换

4.5 包装类

包装类是Java设计之初提出的，次要解决根本数据类型无奈面对对象编程的问题。

装箱：根本数据类型 to 包装类

拆箱：包装类 to 根本数据类型

//int与Integer之间的转换
int x = 5;
Integer y = new Integer(x);
System.out.println("int转换为Integer,y="+y);

int z = y.intValue();
System.out.println("Integer转换为int,z="+z);

System.out.println("=======================");

//Integer与String转换
String s1 = "666";
Integer i1 = Integer.parseInt(s1);
System.out.println("String转换为Integer，i1="+i1);

String s2 = i1.toString();
System.out.println("Integer转换为String，s2="+s2);

System.out.println("=======================");


//int与String转换
int xx = 2;
String ss1 = String.valueOf(xx);
System.out.println("int转换为String，ss1="+ss1);

int yy = Integer.parseInt(ss1);
System.out.println("String转换为int,yy="+yy);

System.out.println("=======================");


//JDK1.5后Java采取主动装箱和主动拆箱性能
//主动装箱，编译器执行了Integer x1 = Integer.valueOf(x)
Integer x1 = x;
System.out.println("主动装箱，x1="+x1);

//主动拆箱，编译器执行了 int y1 = y.intValue()
int y1 = y;
System.out.println("主动拆箱，y1="+y1);

面向对象

1，灵魂拷问，什么是面向对象？

百度的解释：

面向对象(Object Oriented)是软件开发办法。面向对象的概念和利用已超过了程序设计和软件开发，扩大到如数据库系统、交互式界面、利用构造、利用平台、分布式系统、网络管理构造、CAD技术、人工智能等畛域。面向对象是一种对事实世界了解和形象的办法，是计算机编程技术倒退到肯定阶段后的产物。 面向对象是绝对于面向过程来讲的，面向对象办法，把相干的数据和办法组织为一个整体来对待，从更高的档次来进行零碎建模，更贴近事物的天然运行模式。

网上有一个活泼的例子来阐明面向对象的特点：

我要用洗衣机洗衣服，只须要按一下开关和洗涤模式就能够了。有必要理解洗衣机内 部的构造吗？有必要碰电动机吗？有必要理解如何通电的吗？

这是一个很“实在”的例子，没有人会为了应用洗衣机去学一下电学的组成原理，但咱们却不便使用者洗衣机，手机，电脑等各种各样的事物却并不理解它们的原理。这是坏事还是好事？洗衣机能够洗脏衣服，手机能够和亲朋好友打电话，电脑能够帮忙咱们不便的解决难以解决的各种问题。但这个世界上并不是没有人不懂洗衣机的原理，手机的制作，电脑的组装。咱们不懂其内部结构却失常的应用着这些设施，并不是单纯科技的提高，而是人类对于事物的解决思路产生了变动，究其基本是为了更高的效率！设计手机的人兴许用着他人制作的洗衣机，敲着键盘的人是另一个畛域的创造者，社会分工明确，整体效率极大晋升，你只需专一一项，就可取得所有的便当。

回到面向对象的问题上来，什么是面向对象呢？

集体认为：如果摒弃软件开发的领域，这是一种通过明确社会分工而提高效率的办法。在软件开发的范畴内，就是通过形象出零碎性能而实现最大化代码复用的开发模式。

面向对象的延长：

面向对象是软件开发的名词，但其中蕴含的是这个世界的倒退法则。

比方，住房子不肯定本人建，也能够买；吃饭不肯定本人做，也能够进来吃或者叫外卖；至于洗衣机，电脑冰箱这些更不必提了。你只须要做好本人的事，剩下的，交给其他人就好了。

在软件开发的领域内，除了编写代码上使用了面向对象的思维，应用第三方框架等同样是面向对象的延长，从底层的操作系统，JVM虚拟机，包含Java语言，咱们并不需要从新再创造一遍，站在伟人的肩膀上，咱们能做的事更多。

2，如何实现面向对象？——封装，继承，多态

2.1 封装

• 什么是封装？

  外围：通过暗藏实现，裸露接口，一来实现代码解耦，二来通过拜访修饰符保障数据安全。

• 如何保障数据安全

  比如说设置年龄，能够在set中加个if强制不能超过30岁。（同理，不能为空等等能够保障数据安全）
  
  public void setAge(int age) {
  if(age>=30){
  this.age=18;
  }else{
  this.age = age;
  }
  }

参考这位女司机豪横：https://zhuanlan.zhihu.com/p/37853346

2.2 继承

外围目标：实现代码复用。

• 继承规定

  • 子类具备父类非private的属性和办法
  • 子类能够扩大本人的属性和办法

• 结构器会被继承吗？

  • 结构器是不会被子类继承的，但子类的对象在初始化时会默认调用父类的无参结构器。

    子类会继承父类的数据，所以必须要看父类是如何对数据进行初始化的；故子类在进行对象初始化时，会先调用父类的构造函数。

• 当父类显式写了有参结构器，且没有无参结构器。子类继承父类的时候必须显式的调用父类的有参结构器。调用的形式能够应用super(a,b)来调用。
• 子类，父类初始化程序

  准则：动态优于非动态，父类优于子类
  
  - 父类动态变量，动态语句块
  - 子类动态变量，动态语句块
  
  - 父类非动态代码块，结构器
  - 子类非动态代码块，结构器

  class Base {
  // 1.父类动态代码块
  static {
  System.out.println("Base static block!");
  }
  // 3.父类非动态代码块
  {
  System.out.println("Base block");
  }
  // 4.父类结构器
  public Base() {
  System.out.println("Base constructor!");
  }
  }
  
  public class Derived extends Base {
  // 2.子类动态代码块
  static{
  System.out.println("Derived static block!");
  }
  // 5.子类非动态代码块
  {
  System.out.println("Derived block!");
  }
  // 6.子类结构器
  public Derived() {
  System.out.println("Derived constructor!");
  }
  public static void main(String[] args) {
  new Derived();
  }
  }

  Base static block!
  Derived static block!
  Base block
  Base constructor!
  Derived block!
  Derived constructor!

• 继承之父——Object类

  Object类是所有Java类的根父类 ，如果在类的申明中未应用extends关键字指明其父类，则默认父类 为java.lang.Object类（任何类都能够调用Object的办法）

  【Object的次要组成】

  • public native int hashCode(); 获得hash码

    hash码是依据肯定的规定将与对象相干的信息（比方对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。次要作用是为了配合基于散列的汇合一起失常运行，这样的散列汇合包含HashSet、HashMap以及HashTable。

    当汇合要增加新的对象时，先调用这个对象的hashCode办法，失去对应的hashcode值，如果table中没有该hashcode值，它就能够间接存进去，不必再进行任何比拟了；如果存在该hashcode值，就调用它的equals办法与新元素进行比拟，雷同的话就不存了，不雷同就散列其它的地址。

  • equals（Object obj） 比拟对象
  • clone（） 可用于简单对象的深拷贝

2.3 多态

• 什么是多态？

  一类事物的多种体现状态。（比方手机有各种各样的品牌，但都属于手机这一类事物）

• 多态的体现形式：重载，重写

  办法重载：同一个类中，办法名雷同，参数或者参数的个数不同

  办法重写：类产生了继承关系，子类重写父类办法（办法名，参数，返回类型必须与父类统一）

• 向上转型

  将子类对象转化为父类对象，目标：调用父类的公共办法

  规定：能够拜访父类独有的办法和子类重写父类的办法，无法访问子类扩大的办法

  [如果有100个类继承了同一个父类，父类的办法能够被这100个类应用，相比于在子类中一一定义，在父类中定义具备更好的代码复用性]

  Father是父类，Son类继承自Father。
  
  Father f1 = new Son(); //（向上转型)
  
  Son s1 = (Son)f1; //(向下转型，父类转换为子类)

• 向下转型

  将父类对象转换为子类对象，目标：调用子类独有的办法（为什么不间接new一个子类对象？？？）

  规定：能够调用父类的办法，子类重写父类的办法，子类扩大的办法

  Father是父类，Son类继承自Father。

  Father f1 = new Son();

  Son s1 = (Son)f1; //(向下转型，父类转换为子类，注：父类对象无奈间接转换为子类对象，向下转型前必须先向上转型)

3，关键字盘点

3.1 static

static能够润饰办法，变量，代码块，类，前两种利用更加常见。

• static润饰办法

  static润饰的办法称为静态方法，也称类办法，能够间接通过类名.办法名间接拜访，不须要实例化对象拜访。

  规定：

  • 非static办法能够拜访static办法.
  • static办法不能拜访非static办法
• static润饰变量

  static润饰的变量称为动态变量，也称类变量，全局变量，能够间接通过类名.变量名间接拜访，不须要实例化对象拜访。

• static的继承问题

  子类是不会继承父类被static润饰的办法和变量，然而能够调用。

• static润饰代码块

  代码块的作用：对类或对象进行初始化。

  动态代码块【static润饰】

  • 不能够对非动态的属性初始化。即：不能够调用非动态的属性和办法。
  • 动态代码块的执行要先于非动态代码块。
  • 动态代码块随着类的加载而加载，且只执行一次

非动态代码块- 除了调用非动态的构造外，还能够调用动态的变量或办法。 - 每次创建对象的时候，都会执行一次。且先于结构器执行。

3.2 final

final关键字能够润饰类，办法，变量。

• final润饰类

  不能被继承

• final润饰办法

  办法不能被子类重写

• final润饰变量

  润饰根本数据类型的变量，想当于定义了一个常量。

  final int x =5;
  x=6;//报错

  润饰援用类型的变量，固定栈，不固定堆，也就是援用变量的地址是不可变的，然而援用地址指向的堆中的内容是可变的。

  final StringBuffer s = new StringBuffer("hello");
  s.append("world");