前言

1、概述

计算机包括硬件(hardware)和软件(software)两部分。硬件包括计算机中可以
看得见的物理部分。而软件提供看不见的指令。这些指令控制硬件并且使得
硬件完成特定的任务。
程序设计
定义：创建（或开发）软件。软件包含了指令，告诉计算机做什么。
应用场景：软件遍布我们周围。除了个人计算机，飞机、汽车、手机甚至烤
面包机中，同样运行着软件。
程序设计语言
软件开发人员在称为程序设计语言的强大工具的帮助下创建软件。

2、计算机硬件介绍

冯·诺依曼体系结构是现代计算机的基础，现在大多计算机仍是冯·诺依曼计算机的组
织结构，只是作了一些改进而已，并没有从根本上突破冯体系结构的束缚。冯·诺依曼
也因此被人们称为“计算机之父”。

2.1、中央处理器

中央处理器(Central Processing Unit,CPU)是计算机的大脑。它从内存中获取指令，然后执行这些指令。
包括：控制单元(control unit)和算术/逻辑单元(arithmetic/login unit)。
控制单元：用于控制和协调其他组件的动作。
算术/逻辑单元：用于完成数值运算(+、-、*、/)和逻辑运算(比较)。
每台计算机都有一个内部时钟，该时钟以固定速度发射电子脉冲。时钟速度越快，在给定的时间段内执行的指令就越多。速度的计量单位是赫兹(Hz)，1Hz相当于每秒1个脉冲。随着CPU速度不断提高，目前以千兆赫(GHz)来表述。
最初一个CPU只有一个核(core)。核是处理器中实现指令读取和执行的部分。一个多核CPU是一个具有两个或者更多独立核的组件。可提高CPU的处理能力。

2.2、IT定律之计算机行业发展规律

摩尔定律(Moore’s Law) 
安迪-比尔定律(Andy and Bill’s Law) 
反摩尔定律(Reverse Moore’s Law)

2.3存储设备

内存中的信息在断电时会丢失。那我们可以考虑将程序和数据永久的保存在存储设备上。当计算机确实需要这些数据时，再移入内存，因为从内存中读取比从存储设备读取要快得多。
存储设备主要有以下三种：
>磁盘驱动器
每台计算机至少有一个硬盘驱动器。硬盘(hard disk)用于永久的保存数据和程序。
>光盘驱动器(CD和DVD)
CD的容量可达700MB。DVD的容量可达4.7GB。
>USB闪存驱动器
USB: Universal Serial Bus，通用串行总线。可以使用USB将打印机、数码相机、鼠标、外部硬盘驱动器连接到计算机上。USB闪存驱动器很小，可用于存储和传输数据的设备

2.4、比特(bit)和字节(byte)

>计算机就是一系列的电路开关。每个开关存在两种状态：关(off)和开(on)。如果电路是开的，它的值是1
。如果电路是关的，它的值是0。
>一个0或者一个1存储为一个比特(bit)，是计算机中最小的存储单位。
>计算机中是最基本的存储单元是字节(byte) 。每个字节由8个比特构成。
>计算机的存储能力是以字节和多字节来衡量的。如下：
千字节(kilobyte,KB) = 1024B
兆字节(megabyte,MB) = 1024KB
千兆字节(gigabyte,GB) = 1024MB
万亿字节(terabyte,TB) = 1024GB

2.5、内存

内存(也叫 Random-Access Memory,RAM)：由一个有序的字节序列组成，用于存储程序及程序需要的数据。
>一个程序和它的数据在被CPU执行前必须移到计算机的内存中。CPU操作的数据都来自于内存。
>每个字节都有一个唯一的地址。见右图。使用这个地址确定字节的位置，以便于存储和获取数据。
>一个计算机具有的RAM越多，它的运行速度越快，但是此规律是有限制的。
>内存与CPU一样，也构建在表面嵌有数百万晶体管的硅半导体芯片上。但内存芯片更简单、更低速、更便宜。
实测发现：内存存取数据的速度比硬盘的存取速度快10倍，在某些环境里，硬盘和内存之间的速度差距可能
会更大。而CPU的速度比内存不知还要快多少倍。当我们把程序从硬盘放到内存以后，CPU就直接在内存运行
程序，这样比CPU直接在硬盘运行程序就要快很多。
>内存解决了一部分CPU运行过快，而硬盘数据存取太慢的问题。 提高了我们的电脑的运行速度。内存就如
同一条“高速车道”一般，数据由传输速度较慢的硬盘通过这条高速车道传送至CPU进行处理！
>但内存是带电存储的(一旦断电数据就会消失)，而且容量有限，所以要长时间储存程序或数据就需要使用
硬盘。
>内存在这里起了两个作用：
1. 保存从硬盘读取的数据，提供给CPU使用
2. 保存CPU的一些临时执行结果，以便CPU下次使用或保存到硬盘

2.6、输入、输出设备

常见的输入设备：键盘（keyboard）和鼠标（mouse）
常见的输出设备：显示器（monitor）和打印机（printer）
显示器屏幕分辨率：是指显示设备水平和垂直方向上显示的像素(px)数。
>分辨率可以手工设置。
>分辨率越高，图像越锐化、越清晰。

2.7、通信设备

计算机可以通过通信设备进行联网。
常见的设备有：
>拨号调制解调器：使用的是电话线，传输速度可达56 000bps(bps:每秒比特)
>DSL（数字用户线）：使用的也是电话线，但传输速度叫上面的快20倍
>电缆调制解调器：利用有线电视电缆进行数据传输，通常速度比DSL快。
>网络接口卡（NIC）：将计算机接入局域网（LAN）的设备。局域网通常用于大学、商业组织和政府组织。速度甚至可达1000Mbps
>无线网络：在家庭、商业和学校中极其常见。计算机可通过无线适配器连接到局域网或internet上。

3、计算机发展史上的鼻祖

3.1、阿兰·图灵(Alan Turing)

最近半个世纪以来，世界计算机科学界的重大进步，离不开图灵等人的理论奠基作用和多方面的开创性研究成果。图灵是当之无愧的计算机科学和人工智能之父。甚至认为，他在技术上的贡献及对未来世界的影响几乎可与牛顿、爱因斯坦等巨人比肩。
图灵论文中的“用有限的指令和有限的存储空间可算尽一切可算之物”理论让当时所有的科学家震惊
美国计算机学会（ACM）的年度“图灵奖”，自从1966年设立以来，一直是世界计算机科学领域的最高荣誉，相当于计算机科学界的诺贝尔奖。至今，中国人只有姚期智院士获该奖项

3.2、冯·诺依曼(John von Neumann)

20世纪最重要的数学家之一，在现代计算机、博弈论、核武器和生化武器等诸多领域内有杰出建树的最伟大的科学全才之一，被后人称为“计算机之父”和“博弈论之父”。
计算机基本工作原理是存储程序和程序控制，它是由世界著名数学家冯·诺依曼提出的。最简单的来说，冯诺依曼理论的要点是：数字计算机的数制采用二进制；计算机应该按照程序顺序执行。
同样有着“计算机之父”称号的冯·诺依曼的助手弗兰克尔在一封信中写到：“……计算机的基本概念属于图灵。按照我的看法，冯·诺依曼的基本作用是使世界认识了由图灵引入的计算机基本概念……”

根据冯诺依曼体系结构构成的计算机，必须具有如下功能：
>把需要的程序和数据送至计算机中。
>必须具有长期记忆程序、数据、中间结果及最终运算结果的能力。
>能够完成各种算术、逻辑运算和数据传送等数据加工处理的能力。
>能够根据需要控制程序走向，并能根据指令控制机器的各部件协调操作。
>能够按照要求将处理结果输出给用户。

4、操作系统

操作系统(Operating System)是运行在计算机上的最重要的程序，它可以管理和控制计算机的活动。
>硬件、操作系统、应用程序和用户之间的关系如右图。
>操作系统的主要任务：
>控制和监视系统的活动
>分配和调配系统资源
>调度操作

5、万维网

万维网（World Wide Web,www,环球信息网）常简称为Web,发明者蒂姆·伯纳斯·李。分为Web客户端和Web服务器程序。 WWW可以让Web客户端（常用浏览器）访问浏览Web服务器上的页面。 是一个由许多互相链接的超文本组成的系统，通过互联网访问。在这个系统中，每个有用的事物，称为一样“资源”；并且由一个全局“统一资源标识符”（URI）标识；这些资源通过超文本传输协议（Hypertext Transfer Protocol）传送给用户，而后者通过点击链接来获得资源。
www.sina.com
万维网<-因特网<-互联网  包含关系
万维网是无数个网络站点和网页的集合，它们在一起构成了因特网Internet最主要的部分（因特网也包括电子邮件、Usenet以及新闻组）。它实际上是多媒体的集合，是由超级链接连接而成的。我们通常通过网络浏览器上网观看的，就是万维网的内容。

8大基本数据类型及其包装类

byte short int long float double char boolean
Byte Short Integer Long Float Double Charracter Boolean

1、 Java语言概述

1.1、软件开发介绍

>软件开发
软件，即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分。
>人机交互方式
>图形化界面(Graphical User Interface GUI)这种方式简单直观，使用
者易于接受，容易上手操作。
>命令行方式(Command Line Interface CLI)：需要有一个控制台，输
入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些
命令。
Pascal之父Nicklaus Wirth： “Algorithms+Data Structures=Programs”

1.2、常用DOS命令与快捷键

常用的DOS命令
>dir : 列出当前目录下的文件以及文件夹
>md : 创建目录
>rd : 删除目录
>cd : 进入指定目录
>cd.. : 退回到上一级目录
>cd\: 退回到根目录
>del : 删除文件
>exit : 退出 dos 命令行
补充：echo javase>1.doc
例子：删除非空文件夹？
del 文件夹名->y->rd 文件夹名
常用快捷键
>← →：移动光标
>↑ ↓：调阅历史操作命令
>Delete和Backspace：删除字符

1.3、Java语言概述

是SUN(Stanford University Network，斯坦福大学网络公司 ) 1995年推出的一
门高级编程语言。
>是一种面向Internet的编程语言。Java一开始富有吸引力是因为Java程序可以在Web浏览器中运行。这些Java程序被称为Java小程序（applet）。applet使用现代的图形用户界面与Web用户进行交互。 applet内嵌在HTML代码中。
>随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。
后台开发：Java、PHP、Python、Go、Node.js

1.3.1、Java简史

 1991年 Green项目，开发语言最初命名为Oak (橡树)
 1994年，开发组意识到Oak 非常适合于互联网
 1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作
 1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最
 1998年，发布JDK 1.2，同年发布企业平台J2EE
 1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
>重要
 2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
 2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
 2009年，Oracle公司收购SUN，交易价格74亿美元
 2011年，发布JDK 7.0
>重要
 2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本
 2017年，发布JDK 9.0，最大限度实现模块化
 2018年3月，发布JDK 10.0，版本号也称为18.3
 2018年9月，发布JDK 11.0，版本号也称为18.9

1.3.2、Java技术体系平台

>Java SE(Java Standard Edition)标准版
支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE
>Java EE(Java Enterprise Edition)企业版
是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技如:Servlet 、Jsp等，主要针对于Web应用程序开发。版本以前称为J2EE
>Java ME(Java Micro Edition)小型版
支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME
>Java Card
支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台

1.3.3、Java在各领域的应用

从Java的应用领域来分，Java语言的应用方向主要表现在以下几个方面：
• 企业级应用：主要指复杂的大企业的软件系统、各种类型的网站。Java的安全机制以及
它的跨平台的优势，使它在分布式系统领域开发中有广泛应用。应用领域包括金融、电信、交通、电子商务等。
• Android平台应用：Android应用程序使用Java语言编写。Android开发水平的高低很大程度上取决于Java语言核心能力是否扎实。
• 大数据平台开发：各类框架有Hadoop，spark，storm，flink等，就这类技术生态圈来讲，还有各种中间件如flume，kafka，sqoop等等 ，这些框架以及工具大多数是用Java编写而成，但提供诸如Java，scala，Python，R等各种语言API供编程。
• 移动领域应用：主要表现在消费和嵌入式领域，是指在各种小型设备上的应用，包括手机、PDA、机顶盒、汽车通信设备等。

1.3.4、Java语言的诞生

java之父James Gosling团队在开发”Green”项目时，发现C缺少垃圾回收系统，还有可移植的安全性、分布程序设计和多线程功能。最后，他们想要一种易于移植到各种设备上的平台。
Java确实是从C语言和C++语言继承了许多成份，甚至可以将Java看成是类C语言发展和衍生的产物。比如Java语言的变量声明，操作符形式，参数传递，流程控制等方面和C语言、C++语言完全相同。但同时，Java是一个纯粹的面向对象的程序设计语言，它继承了C++语言面向对象技术的核心。Java舍弃了C语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）、多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间。JDK1.5又引入了泛型编程（Generic 
Programming）、类型安全的枚举、不定长参数和自动装/拆箱

1.3.5、Java语言的主要特性

• Java语言是易学的。Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。
• Java语言是强制面向对象的。Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
• Java语言是分布式的。Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
• Java语言是健壮的。Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
• Java语言是安全的。Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查。
• Java语言是体系结构中立的。Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。
• Java语言是解释型的。如前所述，Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统的解释器中运行。
• Java是性能略高的。与那些解释型的高级脚本语言相比，Java的性能还是较优的。
• Java语言是原生支持多线程的。在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。

1.4、Java语言运行机制及运行过程

1.4.1、Java语言的特点

特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态
特点二：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制
特点三：跨平台性
跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere”
原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

1.4.2、Java语言的特点：跨平台性

因为有了JVM，同一个Java 程序在三个不同的操作系统中都可以执行。这样就实现了Java 程序的跨平台性。

1.4.3、Java两种核心机制

Java虚拟机 (Java Virtal Machine)
垃圾收集机制 (Garbage Collection)

1.4.4、核心机制—Java虚拟机

JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器。
对于不同的平台，有不同的虚拟机。
只有某平台提供了对应的java虚拟机，java程序才可在此平台运行
Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”

1.4.5、核心机制—垃圾回收

不再使用的内存空间应回收—— 垃圾回收。
在C/C++等语言中，由程序员负责回收无用内存。
Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。
垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。
Java程序还会出现内存泄漏和内存溢出问题吗？Yes!

1.5、开发环境搭建

1.5.1、什么是JDK、JRE

>JDK(Java Development Kit Java开发工具包)
JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
 其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等
>JRE(Java Runtime Environment Java运行环境) 
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
简单而言，使用JDK的开发工具完成的java程序，交给JRE去运行。

1.5.2安装JDK

官方网址：
www.oracle.com
java.sun.com
安装JDK
傻瓜式安装，下一步即可。
建议：安装路径不要有中文或者空格等特殊符号。
如果操作系统是64位的，软件尽量选择支持64位的（除非软件本身不区分）。
当提示安装 JRE 时，正常在JDK安装时已经装过了，但是为了后续使用Eclipse等开发
工具不报错，建议也根据提示安装JRE。

1.5.3、配置环境变量

1、path中直接添加bin目录路径
2、配置JAVA_HOME

1.5.4、检测是否配置好环境变量

--javac
--java
--java -verion

1.5.5、第一个程序HelloWorld

1、创建HelloWorld.java文件
2、cmd窗口cd到该文件目录下
3、编译 javac HelloWorld.java
4、运行 java HelloWorld（java 类名）

1.6、注释

用于注解说明解释程序的文字就是注释。
Java中的注释类型：
 单行注释
 多行注释
 文档注释 (java特有)
提高了代码的阅读性；调试程序的重要方法。
注释是一个程序员必须要具有的良好编程习惯。
将自己的思想通过注释先整理出来，再用代码去体现

1.6.1、单行注释

//

1.6.2、多行注释

/*  */   不能嵌套使用

1.6.3、文档注释

/**内容*/

1.7、第一个程序小结

Java源文件以“java”为扩展名。源文件的基本组成部分是类（class），如
本例中的HelloWorld类。
Java应用程序的执行入口是main()方法。它有固定的书写格式：
public static void main(String[] args) {...}
Java语言严格区分大小写。
Java方法由一条条语句构成，每个语句以“;”结束。
大括号都是成对出现的，缺一不可。
一个源文件中最多只能有一个public类。其它类的个数不限，如果源文件包含
一个public类，则文件名必须按该类名命名。

1.8、Java API的文档

API （Application Programming Interface,应用程序编程接口）是 Java 提供
的基本编程接口。
Java语言提供了大量的基础类，因此 Oracle 也为这些基础类提供了相应的
API文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。
下载API：
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Additional Resources-Java SE 8 Documentation下载。
详见：JDK8的下载-安装-配置.doc

2、基本语法

2.1、关键字与保留字

2.1.1关键字

关键字(keyword)的定义和特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

2.1.2、保留字

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
goto 、const

2.2、标识符

标识符：
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧：凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则：
由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
练习：miles, Test, a++, --a, 4#R, $4, #44, apps, class, public, int, x, y, radius

2.2.1、Java中的名称命名规范

Java中的名称命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个
单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
 注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
 注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议用。

2.3、变量

变量的概念：
内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
变量的作用：
用于在内存中保存数据
使用变量注意：
Java中每个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的作用域：其定义所在的一对{ }内
变量只有在其作用域内才有效
同一个作用域内，不能定义重名的变量
声明变量
 语法：<数据类型> <变量名称>
 例如：int var;
变量的赋值
 语法：<变量名称> = <值>
 例如：var = 10;
声明和赋值变量
 语法： <数据类型> <变量名> = <初始化值>
 例如：int var = 10;

2.3.1、变量的分类

对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。

2.3.1.1、变量的分类-按声明的位置的不同

 在方法体外，类体内声明的变量称为成员变量。
 在方法体内部声明的变量称为局部变量。

2.3.2、基本类型->整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

2.3.3、基本类型->浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
浮点型常量有两种表示形式：
 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
 科学计数法形式:如：5.12e2 512E2 100E-2
 float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。
 Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

2.3.4、基本类型->字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：
字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 
= '中'; char c3 = '9';
 Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
例如：char c3 = ‘\n’; // '\n'表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表
一个十六进制整数。如：\u000a 表示 \n。
char类型是可以进行运算的。因为它都对应有Unicode码。
注意：可以声明中文，但是只能存储一个，char a=’中'

2.3.5、了解：ASCII 码

在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从0000000 到 11111111。
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的
关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如
空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这
128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前
面的1位统一规定为0。
缺点：
 不能表示所有字符。
 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel(ג)

2.3.5、了解：Unicode编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有到三个字节是0，这对于存储空间来说是极大的浪费。

2.3.6、了解： UTF-8

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。
UTF-8的编码规则：
对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

2.3.7、基本类型->布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于程序流程控制：
if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句；
boolean类型数据只允许取值true和false，无null。
不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。———《java虚拟机规范 8版》

2.3.8、基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
注意：
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

2.3.9、字符串类型：String

 String不是基本数据类型，属于引用数据类型
 使用方式与基本数据类型一致。例如：String str = “abcd”;
 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str + “xyz” ; 
int n = 100;
str = str + n;

2.3.10、强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
如： String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。

2.3.11、进制

所有数字在计算机底层都以二进制形式存在。
对于整数，有四种表示方式：
二进制(binary)：0,1 ，满2进1.以0b或0B开头。
十进制(decimal)：0-9 ，满10进1。
八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大写。
如：0x21AF +1= 0X21B0

2.3.11.1、二进制

Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位
二进制的整数有如下三种形式：
原码：直接将一个数值换成二进制数。最高位是符号位
负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
负数的补码：其反码加1。
计算机以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码+1
为什么要使用原码、反码、补码表示形式呢？
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。

略

2.4、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符

2.4.1、算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的结果是？3000
“+”除字符串相加功能外，还能把非字符串转换成字符串.例如：
System.out.println(“5+5=”+5+5); //打印结果是？ 5+5=55 ?

2.4.2、赋值运算符

符号：= 
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
类型转换原则进行处理。
支持连续赋值。
扩展赋值运算符： +=, -=, *=, /=, %=

2.4.3、比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==”不能误写成“=” 。

2.4.4、逻辑运算符

&—逻辑与 | —逻辑或 ！—逻辑非
&& —短路与 || —短路或 ^ —逻辑异或

2.4.4.1、“&”和“&&”、”|“和”||“、”^“和”|“的区别

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
理解：异或，追求的是“异”!

2.4.5、位运算符

位运算是直接对整数的二进制进行的运算
<< 左移：左移一位在原来的结果上*2
>> 右移：右移一位在原来的结果上/2,最高位原来是1则拿1补是0则拿0补
& 与运算：二进制位都为1则为1，否则为0
| 或运算：二进制有1则为1
^ 异或运算：二进制都为1则为0，有1则为1
~ 去反运算：二进制取反，符号位也相应改变
面试题：最高效的方式计算2*8？2<<3或8<<1
练习：交换两个变量的值
int num1=10;
int num2=20;
方式1：临时变量temp
方式2：
num1=num1+num2;
num2=num1-num2;
num1=num1-num2;
方式3：
num1=num1^num2;
num2=num1^num2;
num1=num1^num2;

2.4.5.1、位运算符的细节

2.4.6、三元运算符

2.4.6.1、三元运算符的优先级

 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算
符总优先于下一行。
 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

2.5、流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
顺序结构
分支结构
循环结构
顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。
循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

2.5.1、顺序结构

Java中定义成员变量时采用合法的前向引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2；
int num1 = 12;
}

2.5.2、分支语句1： if-else结构

2.5.2.1、分支结构：if-else使用说明

 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
 语句块只有一条执行语句时，一对{}可以省略，但建议保留
 if-else语句结构，根据需要可以嵌套使用
 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓当多个条件是“包含”关系时，“小上大下 / 子上父下”

2.5.2.2、应用举例

public class AgeTest{
public static void main(String args[]){
        int age = 75;
        if (age< 0) {
        System.out.println("不可能！");
        } else if (age>250) {
        System.out.println("是个妖怪！");
        } else {
        System.out.println(“人家芳龄 " + age +" ,马马乎乎啦！");
        }
    }
}

2-5-3 分支语句2： switch-case结构

switch(表达式){
case 常量1:
语句1;
// break;
case 常量2:
语句2;
// break;
… …
case 常量N:
语句N;
// break;
default:
语句;
// break;
}

2.5.3.1、应用举例

public class SwitchTest {
    public static void main(String args[]) {
        int i = 1;
        switch (i) {
        case 0:
        System.out.println("zero");
        break;
        case 1:
        System.out.println("one");
        break;
        default:
        System.out.println("default");
        break;
        }
    }
}

2.5.3.2、switch语句有关规则

 switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
 case子句中的值必须是常量，不能是变量名或不确定的表达式值；
 同一个switch语句，所有case子句中的常量值互不相同；
 break语句用来在执行完一个case分支后使程序跳出switch语句块；如
果没有break，程序会顺序执行到switch结尾
 default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default

2.5.3.3、switch和if语句的对比

if和switch语句很像，具体什么场景下，应用哪个语句呢？
 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几
种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

2.5.4、循环结构

循环结构
在某些条件满足的情况下，反复执行特定代码的功能
循环语句分类
for 循环
while 循环
do-while 循环

2.5.4.1、for循环

public class ForLoop {
    public static void main(String args[]) {
        int result = 0;
        for (int i = 1; i <= 100; i++) {
        result += i;
        }
    System.out.println("result=" + result);
    }
}

2.5.4.2、while循环

public class WhileLoop {
    public static void main(String args[]) {
        int result = 0;
        int i = 1;
        while (i <= 100) {
        result += i;
        i++;
        }
        System.out.println("result=" + result);
    }
}

2.5.4.3、do-while循环

public class DoWhileLoop {
    public static void main(String args[]) {
        int result = 0, i = 1;
        do {
        result += i;
        i++;
        } while (i <= 100);
        System.out.println("result=" + result);
    }
}

2.5.5、嵌套循环(多重循环)

 将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while均可以作为外层循环或内层循环。 
 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的 循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开 始下一次的循环。 
 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

2.5.6、特殊关键字的使用： break、continue

2.5.6.1、break

break 语句 
break语句用于终止某个语句块的执行 
{ 
…… break;
 …… 
 } 
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是 哪一层语句块 
label1: 
{ …… label2: 
    { …… label3: 
        { 
            …… break label2; ……
        } 
    }
}

public class BreakTest{
    public static void main(String args[]){
        for(int i = 0; i<10; i++){ 
        if(i==3)
        break;
        System.out.println(" i =" + i);
        }
        System.out.println("Game Over!");
    }
}

2.5.6.2、continue

continue 语句
continue只能使用在循环结构中
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
continue语句用法举例
public class ContinueTest {
    public static void main(String args[]){
        for (int i = 0; i < 100; i++) {
        if (i%10==0)
        continue;
        System.out.println(i);
        }
    }
}

2.5.6.3、带标签的continue与break

label:for(int i=1;i<=4;i++){
    for(int j=1;i<=4;j++){
        //if(j%4==0)break;//跳出内循环for
        //if(j%4==0)continue;//跳出当次for循环
        //if(j%4==0)break label;//跳出label标签循环
        //if(j%4==0)continue label;//跳出label标签当次循环
    }
}

2.5.7、return的使用

 return：并非专门用于结束循环的，它的功能是结束一个方法。
当一个方法执行到一个return语句时，这个方法将被结束。
 与break和continue不同的是，return直接结束整个方法，不管
这个return处于多少层循环之内

2.5.8、特殊流程控制语句说明

break只能用于switch语句和循环语句中。 
continue 只能用于循环语句中。
二者功能类似，但continue是终止本次循环，break是终止本层循环。 
break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。 
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。 
很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条 语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。

3、数组

3.1、数组的概述

>数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
>数组的常见概念
 数组名
 下标(或索引)
 元素
 数组的长度
 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
 数组的长度一旦确定，就不能修改。
 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
>数组的分类：
 按照维度：一维数组、二维数组、三维数组、…
 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

3.2、一元数组的使用

>一维数组的声明方式：
type var[] 或 type[] var；
例如：
int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组
 Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

3.2.1、一元数组初始化

3.2.1.1、动态初始化

数组声明且为数组元素分配空间与赋值的操作分开进行
int[] arr = new int[3];        String names[];
arr[0] = 3;                    names = new String[3];
arr[1] = 9;                    names[0] = “钱学森”;
arr[2] = 8;                    names[1] = “邓稼先”;
                            names[2] = “袁隆平”;

3.2.1.2、静态初始化

在定义数组的同时就为数组元素分配空间并赋值。
int arr[] = new int[]{ 3, 9, 8};
或
int[] arr = {3,9,8};
String names[] = {“李四光”,“茅以升”,“华罗庚”}

3.2.2、数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]
 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new 
int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
数组一旦初始化，其长度是不可变的

3.2.3、数组元素的默认初始化值

3.3、多维数组

 Java 语言里提供了支持多维数组的语法。
 如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格，像右图Excel中的表格一样。
 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

3.3.1、多维数组的格式

1、格式1（动态初始化）
int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
2、格式2（动态初始化）
int[][] arr = new int[3][];
二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意：区别于格式1）
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
注：int[][]arr = new int[][3]; //非法
3、格式3（静态初始化）
int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
 Java中多维数组不必都是规则矩阵形式

3.4、数组中涉及到的常见算法

3.4.1、二分查找算法

前提：所要查找的数组必须有序

 public static void main(String[] args) {
        int[] arr={-99,-34,-1,0,9,19,34,55,88};
        int dest=37;
        boolean flag=false;
        int start= 0;
        int end=arr.length-1;
        int mid;
        while(start<=end){
            mid=(start+end)/2;
            if(arr[mid]==dest){
                System.out.println("找到了，dest的索引位置为"+mid);
                flag=true;
                break;
            }else if(arr[mid]>dest){
                end=mid-1;
            }else {
                start=mid+1;
            }
        }
        if(flag==false){
            System.out.println("没有找到该数");
        }
    }

3.4.2、冒泡排序

10个元素需要9次for循环
每次循环比较相邻两个数
冒泡排序是稳定的

 public static void main(String[] args) {
        int[] arr={0,9,-8-18,-66,88,45,77};
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

3.5、各种排序算法的横向比较

3.6、Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
boolean equals(int[] a,int[] b)    判断两个数组是否相等。
String toString(int[] a)            输出数组信息。
void fill(int[] a,int val)           将指定值填充到数组之中。
void sort(int[] a)                    对数组进行排序。快排
int binarySearch(int[] a,int key)  对排序后的数组进行二分法检索指定的值。二分查找，返回值>=0
                                                                        时，找到该数

3.6、数组使用中的常见异常

1、数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[2]);
System.out.println(arr[-1]);
访问到了数组中的不存在的脚标时发生。
2、空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。

4、面向对象-上

4.1、概述

1、面向对象的三大特性:继承、多态、封装
2、类与对象
3、类的成员属性与成员方法
4、每个对象都有一套自己的成员属性（非static）
5、对象的内存解析

6、权限修饰符：public、private、默认、protected
7、成员变量与局部变量的默认初始值
（1）成员变量：===》加载到堆空间
整型：byte、short、int、long ==》0
浮点型：float、double==》0.0
字符型：char==》’0’或’\u0000’
布尔型：boolean==》false
引用类型：类、数组、接口==》null
（2）局部变量没有默认初始值，得先赋值后再使用。===》加载到栈
8、成员方法
9、属性在堆空间，局部变量在栈内存
10、匿名对象：new Person（），只能用一次

4.2、方法重载：

（1）与返回值无关，在同一个类中
（2）方法名必须相同
（3）参数类型及参数列表必须不同

4.3、可变参数

public class MainTest {
    public static void main(String[] args) {
        MainTest mainTest = new MainTest();
        mainTest.show("a");
        mainTest.show("a","b");
        mainTest.show("a","b","c");
    }
    public void show(String ... s){
        System.out.println("可变参数");
    }
    //相当于是一个string数组的形式
    //public void show(String[] s){}
    //错误方式，可变参数可能放在末尾，并且只能有一个可变参数
    //public void show(String ... s,int i){ }
}

4.4、参数传递

int[] arr={1,2,3};
sout(arr);//地址值
char[] ch={'a','b','c'};//char也可以存储中文，但是只能存一个，因为一个中文占两个字节
sout(ch);//abc

4.5、封装性

4.5.1、四种权限修饰符

4.5.2、this调用构造器

（1）如果一个类有n个构造器，只能最多有n-1次this调用构造器
（2）this调用构造器只能放在第一行

5、面向对象-中

5.1、继承的好处

1、减少代码量
2、提高拓展性
3、为多态提供了准备

5.2、其他

1、私有的属性和方法仍然可以被继承，只是由于封装性不能直接利用对象调用
2、单继承
3、所有的java类（除Object类本身）都直接或间接继承Object类
4、重写父类中的方法后，覆盖了父类中的方法，拓展功能

5.3、方法重载与方法重写的区别

重写：
（1）方法名、参数列表必须一样，
（2）修饰权限不小于父类，
（3）private修饰的方法不能被重写
（4）返回值类型是void，重写返回值也必须是void，基本数据类型也一样。
假设父类返回值为A类型，子类的返回值类型为A类型或A类型的子类
（5）子类重写后的抛出的异常不大于父类中抛出的异常
（6）static等关键字修饰的方法不叫重写

java核心技术

前言