Java入门

计算机入门

什么是计算机？

Computer:全称电子计算机，俗称电脑

能够按照程序运行，自动、高效处理海量数据的现代化智能电子设备

由硬件和软件所组成

常见的形式有台式计算机、笔记本计算机、大型计算机

广泛应用在：科学计算、数据处理、自动控制、计算机辅助设计、人工智能、网络等领域

计算机硬件

一些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。

计算机硬件组成：

CPU

主板

内存

电源、主机箱

硬盘

显卡

键盘、鼠标

显示器

冯·诺依曼体系结构计算机软件

计算机软件可以使计算机按照事先预定好的顺序完成特定的功能

计算机软件按照功能划分为系统软件与应用软件

系统软件：

       DOS（Disk Operating System), Windkws, Linux, Unix,  Mac, Android, ios

应用软件;

       WPS,QQ, 微信，英雄联盟，绝地求生......

软件、开发、软件开发

人机交互（图形化界面、命令行）

Windows常用快捷键

Ctrl+C：复制

Ctrl+V：粘贴

Ctrl+A：全选

Ctrl+X：剪贴

Ctrl+Z：撤销

Ctrl+S：保存

Alt+F4：关闭窗口

基本的Dos命令

打开CDM的方式：

1.开始+系统+命令提示符

2.Win+R  输入cmd打开控制台

3.在任意文件夹下面，按住shift键 + 鼠标右键点击，在此处打开命令行窗口

4.资源管理器的地址栏前面加上cmd 路径

管理员方式运行: 选择以管理员方式运行

常用的Dos命令：

#盘符切换

#查看当前目录下的所有文件 dir

#切换目录   cd change directory

cd ..

#清理屏幕 cls   (clear screen)

#退出终端 exit

#查看电脑的ip ipconfig

#打开应用 

        calc

        mspaint

        notepad

#ping 命令

        ping www.baidu.com

#文件操作

        md   目录名

        rd     目录名

        cd>   文件名

        del    文件名   

计算机语言发展史

第一代语言

       机器语言

第二代语言

       汇编语言

第三代语言

       摩尔定律：当价格不变时，集成电路上可容纳的晶体管数目，约每隔18个月便会增加一倍，性能也将提升一倍。换言之，每一美元所能买到的电脑性能，将每隔18个月翻两倍以上。

        高级语言：面向过程（C），面向对象（C++，JAVA）

Java入门

JAVA帝国的诞生

C&C++

1972年C诞生：

    贴近硬件，运行极快，效率极高。

    操作系统，编译器，数据库，网络系统等

    指针和内存管理

1982年C++诞生：

    面向对象

    兼容C

    图形领域，游戏等

反抗

我们要建立一个新的语言：

     语法有点像C

     没有指针

     没有内存管理

     真正的可移植性，编写一次，到处运行

     面向对象

     类型安全

     高质量的类库

     ......

Java初生

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

图形界面的程序

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

Java 2 标准版（J2SE):去占领桌面

Java 2 移动版（J2ME):去占领手机

Java 2 企业版 （J2EE):去占领服务器

大量的巨头加入

Java发展

他们基于Java开发了居多的平台，系统，工具

   构建工具: Ant, Maven, Jekins

   应用服务器：Tomcat, Jetty, Jboss, Websphere, weblogic

   Web开发：Struts, Spring, Mybatis, Hibernate

   开发工具：intellij idea, Jbuilder, Eclipse, Netbean

2006：Hadoop(大数据领域)

2008：Android(手机端)

Java特性和优势

简单性

面向对象

可移植性

高性能

分布式

动态性

多线程

安全性

健壮性

Java三大特性

Write Once,Run Anywhere   跨平台 JVM虚拟机

JavaSE: 标准版（桌面程序，控制台开发...)

JavaME: 嵌入式开发 （手机，小家电.....)

JavaEE: E企业级开发（web端，服务器开发...)

JDK JRE JVM

JDK: Java Development

JRE: Java Runtime Environment

JVM: JAVA Virtual Machine

安装开发环境

卸载JDK：

1.删除Java的安装目录

2.删除JAVA_HOME

3.删除path下关于java的目录

4.java-version

安装JDK

1.百度搜索JDK8,找到下载地址

2.同意协议

3.下载电脑对应的版本

4.双击安装JDK

5.记住安装的路径

6.配置环境变量

      1.我的电脑-->右键-->属性

       2.环境变量-->JAVA_HOME

       3.配置path变量

7.测试JDK是否安装成功

        1.打开cmd

         2.java -version

HelloWorld

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

2.新建一个java文件

      文件后缀名为.java

       Hello.java

       系统可能没有显示文件后缀名，我们需要手动打开

3.编写代码

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

4.编译javac java 文件，会生成一个class文件

5.运行class文件， java class文件

Java运行机制

编译型

解释性

程序运行机制

JAVA基础

注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但当项目结构一旦复杂起来，就需要用到注释

注释并不会被执行，是给写代码的人看的

书写注释是一个非常好的习惯

平时写代码一定要注意规范

Java中的注释有三种：

      单行注释   //

      多行注释   /*

                        */

      文档注释

标识符和关键字

关键字

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

标识符注意点：

所有的标识符都应该以字母、美元符（$）、或者下划线开始

首字符之后可以是字母、美元符、下划线或数字的任何字符的组成

不能使用关键字作为变量名或方法名

标识符是大小写敏感的

可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音

数据类型

强类型语言

       要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

弱类型语言

Java的数据类型分为两大类

   基本类型

   引用类型

什么是字节？

位(bit)：是计算机内部数据储存的最小单位，110011000是一个八位二进制数

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

1B(byte,字节)=8bit(位)

字符：是指计算机中使用的字母，数字，字和符号

1bit表示1位

1Byte表示一个字节 1B=8b

1024B=1KB

1024KB=1M

1024M=1G

类型转换

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

运算中，不同类型的数据先转化为同一类型，然后进行运算

强制类型转换  高-->低

自动类型转换  低-->高

变量、常量、作用域

变量

变量是什么：就是可以变化的量！

Java是一种强类型语言，每个变量都必须声明其类型

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

注意事项：

    每个变量都有类型，类型可以是基本类型，也可以是引用类型

    变量名必须是合法的标识符

    变量声明是一条完整的语句，因此每一个生命都必须以分号结束

变量作用域：

类变量  前面有static

实例变量   

局部变量   方法里的

public class Variable{
    static int allClicks = 0;
    String str = "hello world";
    
    public void method(){
         int i = 0;
    }
}

常量

常量:初始化后不能再改变值！不会变动的值

所谓常量可以理解成一种特殊的值，它的值被设定后，在程序运行过程中不允许被改变

常量名一般使用大写字符

变量的命名规则

所有变量、方法、类名：见名知意

类成员变量：首字母小写和驼峰原则

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线

类名：首字母大写和驼峰原则

方法名：首字母小写和驼峰原则

运算符

Java语言支持如下运算符

包机制

为了更好地组织，Java提供了包机制，用于区别类名的命名空间

包语句的语法格式为：

package pkg1[.pkg2[.pkg3...]];

一般利用公司域名倒置作为包名

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用import可完成此功能

JavaDoc

javadoc命令是用来生成自己API文档的

参数信息：

 @author 作者名

 @version版本号

 @since指明需要最早使用的jdk版本

 @param参数名 

 @return返回值情况

 @throws异常抛出情况

Java流程控制

之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java,util,Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

基本语法：

Scanner s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般要使用hasNext()与hasNextLine()判断是否还有输入的数据

next():

1.一定要读取到有效字符后才可以结束输入

2.对输入有效字符之前遇到的空白，next()方法会自动将其去掉

3.只有输入有效字符后才将其后面输入的空白作为分隔或者结束符

4.next()不能得到带有空格的字符串

nextLine():

1.以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符

2.可以获得空白

顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行

顺序结构是最简单的算法结构

语句与语句之间，框与框之间是按从上到下的顺序进行的，它是you

选择结构

if单选择结构

if双选择结构

if多选择结构

嵌套的if结构

switch多选择结构

循环结构

while循环

do...while循环

for循环

break continue

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环剩余的语句

continue语句用在循环语句体中，用于种植某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

Java方法

何谓方法？

System.out.println(),那么它是什么呢？

Java方法是语句的集合，它们在一起执行一个功能。

    ·方法是解决一类问题的步骤的有序组合

    ·方法包含于类或对象中

    ·方法在程序中被创建，在其他地方被引用、

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的发展。

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，都是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void

方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数

   形式参数：在方法被调用时用于接收外界输入的数据

   实参：调用方法时实际传给发放的数据

方法体：方法体包含具体的语句，定义该方法的功能

方法调用

调用方法：对象名.方法名（实参列表）

Java支持两种调用方法的方式，根据方法是否返回值来选择

当方法返回一个值的时候，方法调用通常被当作一个值

如果方法返回值是void，fan啊调用一定是一体哦啊语句

Java是值传递

方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法的重载的规则：

  方法名称必须相同

  参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）

  方法的返回类型可以相同也可以不同

  仅仅返回类型不同不足以成为方法的重载

实现理论：

  方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐个去匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

有时候你希望运行一个程序时候再传递给它消息。这要靠命令行参数给main()函数实现

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法

在方法声明中，在指定参数类型后加一个省略号（...)

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

递归

A方法调用B方法，很容易理解

递归就是：A方法调用A方法！就是自己调用自己

利用递归可以可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大的减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合

递归结构包括两个部分：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

Java数组

数组的定义

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;
dataType arrayRefVar[];

Java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始

获取数组长度：

arrays.length

数组的四个基本特点：

·其长度是确定的。数组一旦被创建，它的大小就是不可以改变的

·其元素必须是相同类型，不允许出现混合类型

·数组中的元素可以是任何数据类型，包括基本类型和引用类型

·数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象 的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身实在堆中的

内存分析

Java内存分析

三种初始化

静态初始化

int[] a = {1, 2, 3};

动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

数组的默认初始化

 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被   按照实例变量同样的方式被隐式初始化

数组边界

下标的合法区间：[0, length - 1],如果月结就会报错

        ArrayIndexOutOfBoundsException:数组下标越界异常！

小结：

        数组是相同数据类型的有序集合

        数组也是对象。数组元素相当于对象的成员变量

        数组长度是确定的，不可变的。

数组的使用

普通的For循环

For-Each循环

数组作方法入参

数组作返回值

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

二维数组

int a[][] = new int [2][5];

应用

Arrays类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们使用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用

具有以下常用功能：

        给数组赋值：通过方法

        给数组排序：通过方法。按升序

        比较数组：通过equals方法比较数组中元素是否相等

        查找数组元素：通过方法能对排序好的数组进行二分查找法操作

冒泡排序

冒泡排序无疑是最为出名的排序算法之一，在那个共有八大排序

冒泡排序两层循环，外层冒泡轮数，里层依次比较

我们看到嵌套优化，应该立马得出这个算法的时间复杂度为O（n^2）

稀疏数组

稀疏数组的处理方式是：

        记录数组一共有几行几列，有几个不同值

        把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

面向对象

面向过程&面向对象

面向过程思想

        步骤清晰简单，第一步做什么，第二步做什么......

        面对过程适合处理一些较为简单的问题

面向对象思想

        物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思考

        面向对象适合处理复杂的问题，适合处理需要多人协作的问题

对于描述复杂的事物。为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍然需要面向过程的思路去处理

什么是面向对象

面向对象编程（Object-Oriented Programming,OOP）

面向独享编程的本质就是：以类的方式组织代码，以对象的形式封装数据

抽象

三大特性：

        封装

        继承

        多态

从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是现有类后有对象。类是对象的模板。

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物描述/定义，但是并不能代表某一个具体的事物

        动物、植物、手机、电脑......

对象是抽象概念的具体实例

创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：

        1.必须和类的名字相同

        2.必须没有返回类型，也不能写void

构造器必须要掌握

小结

1.类与对象

        类是一个模板：抽象；对象是一个具体的实例

2.方法

        定义、调用

3.对应的引用

        引用的类型：基本类型（8）

        对象是通过引用来操作的：栈-->堆

4.属性：字段Field成员变量

        默认初始化：

                数字： 0    0.0

                char: u0000

                boolean: false

                引用：null

        修饰符： 属性类型 属性名 = 属性值

5.对象的创建和使用

        必须使用new 关键字创造对象

        对象的属性

        对象的方法

6.类：

        静态的属性

        动态的方法

封装

该露的露，该藏的藏

        我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

封装（数据的隐藏）

        通常。应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

属性私有：get/set

封装的作用：

1.提高程序的安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.增加系统的可维护性

继承

继承的本质是对某一批类的抽象，从而实现对实现世界更好的建模

extends的意思是“扩展”。子类是父类的扩展

JAVA中类只有单继承，没有多继承 一个儿子只有一个爸爸，一个爸爸可以有多个儿子

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有以来、组合、聚合等

继承关系的两个类，一个为子类，一个为父类。子类继承父类，使用关键字extends

object类

super

注意点：

        1.super调用父类的构造方法，必须在构造方法的第一个

        2.super必须只能出现在子类的方法或者构造方法中

        3.super和this不能同时调用构造方法

super&this:

代表的对象不同：

        this:本身调用这个对象

        super:代表父类对象的应用

前提：

        this:没有继承也可以使用

        supper:只能在继承条件才可以使用

构造方法：

        this():本类的构造

        super():父类的构造

方法重写

需要有继承，子类重写父类的方法！

        1.方法名相同

        2.参数列表必须相同

        3.修饰符：范围可以扩大但不能缩小

        4.抛出的异常：范围可以被缩小，但是不能扩大

重写：子类的方法和父类必须一致，方法体不同

为什么需要重写:

        父类的功能，子类不一定需要，或者不一定满足

 多态

通过动态编译，使其具有可扩展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：

        有继承关系

        子类重写父类方法

        父类引用指向子类对象

注意：

        1.多态是方法的多态，属性没有多态性

        2.父类和子类有联系

不能重写：

        1.static 方法，属于类，它不属于实例

        2.final 常量

        3.private方法

instanceof

判断一个对象是什么类型

X instanceof Y 判断X是不是Y的实例

类型转换

1.父类引用指向子类对象

2.把子类转换为父类，向上转型

3.把父类转换为子类，向下转型，需要强制转换

4.意义：方便方法的调用，减少重复的代码，更加简洁

public class Person{
   {
      // 代码块（匿名代码块）
   }
   static {
      // 静态代码块
   }
}

匿名代码块在创建对象时就创建了，在构造器之前

静态代码块在类加载时加载，永久加载一次

静态导入包

import static java.lang.Math.random;

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果是修饰类，那么该类就是抽象类

抽象类中可以没有抽象方法，但是有抽象方法的类一定要申明为抽象类

抽象类，不能使用new关键字来创建对象，它是用来让子类的继承的

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

接口

普通类：只有具体实现

抽象类：具体实现和规范都有

接口：只有规范！自己无法写方法，专业的约束！约束和实现分离：面向接口编程

接口就是规范，定义一组规则，体现了对现实世界中”如果你是...则必须能..."的思想

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守

接口的精髓是对对象的抽象

作用：

1.约束

2.定义一些方法，让不同的人实现

3.默认的方法 public abstract

4.常量 public static final

5.接口不能被实例化，因为接口中没有构造方法

6.implements可以实现多个接口

7.必须要重写接口中的方法

N种内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类

        没有名字初始化类，不用将实例保存到变量中

异常

异常程序在运行过程中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等

异常发生在程序运行期间，它影响了正常的程序执行流程

简单分类

检查性异常：最具代表性的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的

例如要打开一个不存在的文件时，一个异常就发生了

运行时异常：运行时异常可能被程序员避免的异常。可以在编译时忽略

错误(Error)：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略

Error类对象  由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关

Error和Exception的区别：

        Error通常是灾难性的知名的错误，是程序无法控制和处理的，当程序出现这些异常时，Java虚拟机一班会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

异常体系结构

Java把异常当作处理对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类

异常处理机制

抛出异常

捕获异常： 假设要捕获多个异常，要从小到大

异常处理五个关键字：

        try、catch、finally、throw、throws

catch写想要捕获的异常类型

可以不要finally

快捷键：Ctrl + Alt +T

自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可

在程序中使用自定义异常类，大体可以分为一下几个步骤：

        1.创建自定义异常类

        2.在方法中通过throw关键字抛出异常对象

        3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

        4.在出现异常方法的调用者中捕获并处理异常