后端技术学习Week1——Java入门

Day1

距离上次使用Java开发时间已过了很久，所以先快速的复习一下Java的基础语法。

1、注释

注释有三种形式：单行注释（// ----）、多行注释（/* -------- */）、文档注释（/** ------- */）。

其中文档注释的内容将来可以提取到程序说明书中去。

2、字面量

字面值就是数据在程序中的书写方法。

字面量的分类：整数、小数、字符、字符串、布尔值、空值

3、变量

变量是内存中的一块儿区域，可以存储一个数据，存储的数据类可变化。

变量声明格式：数据类型 变量名 = 初始值

变量使用时的注意事项：① 先声明才能使用 ② 一种类型的变量只能存放对应类型的数据 ③ 变量从定义到}有效，同一有效范围内不能定义重名变量 ④ 变量在定义时可不赋予初始值，但在使用前必须先赋值。

变量内数据存储形式：二进制形式。

4、数据类型：分为引用型数据类型与基本数据类型。

基本数据类型：整型、字符型。浮点型（小数）、布尔类型

5、关键字与标志符

关键字：Java自己使用，用户不能拿来作为取名。

标志符：用户所取的名字，不能以数字开头，不能用关键字，区分大小写。

6、类型转换

在实际开发中可能会出现不同类型的变量或数据互相赋值的情况，也存在不同类型数据一起运算的情况，此时其结果的类型要确定下来。

自动类型转换：小范围类型变量可以直接赋值给大范围类型变量

byte → short → int → long → float → double

char→ int

表达式的自动类型转换：在表达式中，小范围的类型变量会自动提升为大范围运算。

强制类型转换：大范围类型的变量不能直接赋值给小范围类型变量，必须进行强制类型转换。（这种方式下可能会出现数据丢失）

数据类型 变量 = （数据类型）其他类型的变量、数据

6、运算符 

此部分过于简单，不予赘述

7、程序流程控制

顺序结构

分支结构：

① if

② switch

下图为一ATM模拟系统中实现账户登录选择功能的业务逻辑，这里不多做赘述。

循环结构

三种循环结构 for循环、while循环、do-while循环，不多赘述

跳转关键字：

break ： 跳出并结束当前所在循环的执行。

continue：跳出循环中当次的执行。

验证码生成小算法练习：

用于生成一个指定位数的验证码。

Day2

 1、数组

在程序中存储一批同种类型的数据

定义方法：

        静态初始化：数据类型[]  数组名 = new  数组类型[]{元素1,元素2,..........,元素n}

                                定义时确定数据

        动态初始化：数据类型[]  数组名 = new  数组类型[n]

                                只确定类型和长度，不确定值

遍历及求和：基本就是先通过一个for循环，访问数组中的每一个元素。求和就是在遍历的基础上预先声明一个变量Sum，赋初值为0，之后每遍历一次就使Sum加上该元素，遍历结束便得到了数组元素和。

2、方法

方法定义的完整格式：

修饰符 返回值类型 方法名(形参列表){

方法体代码

return 返回值；

}

3、一些练习案例

①模拟购物车（方法细节实现不予赘述）

 ②模拟买机票

③数组小练习

④双色球模拟 

 

Day3

面向对象、String、ArrayList

这一部分的学习通过文字介绍比较麻烦，所以通过一个ATM系统地模拟案例来整体把握

ATM系统模拟案例

首先定义一个账户类，处于安全期间，类内所有属性设置为private，并为各属性生成getter和setter函数

 接着是ATM首页的业务逻辑，使用一个简单的死循环。这里定义了个一个AccountList用于记录所有注册的账号

 注册部分

注册部分最后生成卡号用到了一个生成随机字符串的方法

登录部分

登录部分用到了一个检索账户的方法 ，由于这个功能在后续许多业务中都会用，所以单拿出来写成一个方法

 登录后的界面的业务逻辑

查询功能

 存款功能

 取款功能

转账功能

密码修改

账户注销功能

Day4

static 关键字

一、修饰成员变量以及成员方法

修饰成员变量：

①静态成员变量：有static修饰，属于类，与类一起加载，内存中只有一份，可以被共享访问。

使用场景：如果信息要被共享。如：系统在线人数

访问规则：建议用类名访问

②实例成员变量：无static修饰，属于对象，每个对象中都存在一份实例成员变量

使用场景：每个对象中都有这些信息，且信息不共享

访问规则：对象名.实例成员变量

修饰成员方法

①静态成员方法：用static修饰，属于类，与类一起加载，可以被共享访问。

使用环境：做一个通用功能

访问规则：建议用类名访问

②实例成员方法：无static修饰，属于对象，必须用对象触发访问

使用环境：如果这个方法属于对象，且要直接访问对象的实例成员，则声明成实例方法

访问规则：对象名.实例成员方法

二、工具类、代码块、单例

①工具类

工具类里面都是静态方法，为了实现一个公用功能

好处：一次编写，处处可调用，提高代码复用，提升开发效率

P.S. 建议把工具类构造器私有化，因为工具类无需对外创建实例对象

②代码块

静态代码块：static{}

                      属于类，与类一起优先加载，自动触发执行一次

                       可以用于在程序启动时，进行静态资源的初始化操作

实例代码块：（几乎不用）（）

                        属于对象，每次调用构造器构造对象前都会执行一次，再执行构造器

                        初始化实例成员

③单例：一种设计模式，为了解决某个问题

单例解决的问题：对外只产生一个对象

饿汉单例：拿对象时对象已存在

构造器私有，定义静态成员变量存储一个对象

懒汉单例：要拿对象时，才开始创建一个对象

三、 继承

Java允许一个类通过extends与另一个类建立父子关系

格式：子类 extends 父类

特点：子类继承父类后，就可以得到父类的属性和方法，但不能继承父类的构造器

        子类可以共享地去访问父类静态成员

        Java是单继承模式，一个类只能继承一个直接父类

        Java不支持多继承，但支持多层继承

        Java中所有类都是Object类的子类

继承后：成员变量、方法的访问特点——就近原则

                this.子类自己的成员变量

                在子类方法中访问父类成员 super.---

继承后方法重写：重写方法的名称形参列表必须与父类被重写方法的名称和形参一致

                        私有方法不能重写

                        静态方法不能重写

                        重写方法的权限>=被重写方法的权限

继承后子类构造器特点：默认先访问父类无参构造器，再执行自己的构造器

设计规范：子类共用属性和行为放在父类，子类独有属性和方法放在自己那里

四、权限修饰符

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关系
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

  

五、final

 六、常量和枚举类

常量

选择常量做信息标志和分类 代码可读性好 实现了软编码形式

枚举类

七、抽象类

抽象类可以理解成类的不完整设计图，是用来被子类继承的。

一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

抽象类的作用：被子类继承、充当模板，提高代码复用

八、接口

接口是用来被类实现的，实现接口的类成为实现类。

接口可以被类单实现，也可以被类多实现。

一个类实现接口，必须重写玩全部接口的全部抽象方法，否则这个类需要定义成抽象类。

JDK8开始后新增的一些方法：

默认方法：default修饰，实现类对象调用。

静态方法：static修饰，必须用当前接口名调用。

私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用。

他们都会默认被public修饰。

接口的注意事项：

1、接口不能创建对象

2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。

3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。

4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。

5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

Day5

一、多态

概念：同类型的对象，调用同一个行为，表现出不同的行为特征

形式：父类 对象名称 = new 子类构造器；

           接口 对象名称 = new 实现类构造器；

识别技巧：方法调用：编译看左，运行看右；

                  变量调用：编译看左，运行看左；

使用前提：必须继承或实现关系、必须父类类型指向子类对象、方法重写。

优点：右边对象解耦合、父类类型变量作为方法参数，可以接收一切子类对象。

缺点：多态下无法调用子类独有方法。

二、内部类

概念：类里面的类

分类：静态内部类、成员内部类、局部内部类、匿名内部类

静态内部类：

内部类可以访问外部类的静态成员，

外部类的实例成员必须用外部类对象访问。

成员内部类：不加 static 修饰 属于外部类对象，

 内部类可以访问外部类的静态成员 ，

可以直接访问外部类对象的实例成员。

匿名内部类 ：

 方便创建子类对象，最终目的为了简化代码编写，

没有名字的内部类，

写出来就产生一个匿名内部类对象。

三、常用API

如Objects、StringBuilder、Math、System、BigDecimal、Data、SimpleDateFormat、Calender等

P.S. 这部分没啥好说的，都是一些常用的方法，使用时可以参照API文档

四、包装类

包装类是什么：

基本数据类型对应的引用类型；

实现了一切皆对象；

后期集合和泛型不支持基本类型，只能使用包装类。

功能：

可以把基本类型的数据转换成字符串类数据；

可以把字符串类型的数值转换成真是的数据类型。

五、集合 - Collection

	元素存储个数	元素存储类型	适合场景
数组	类型确定，长度固定	基本类型和引用类型	数据个数和类型确定的场景
集合	类型可以不固定，长度可变	引用类型	数据个数不定，且要做增删操作的场景

①LIst系列集合

添加的元素是有序、可重复、有索引的；

如 ArrayList、LinkedList；

②Set系列集合

添加的元素无序、不重复、无索引；

如HashSet：无序、不重复、无索引；

LinkedHashSet：有序、不重复、无索引；

TreeSet：按照大小默认升序排序、不重复、无索引

③Collection集合遍历方式

1.如果希望元素可以重复，又有索引，索引查询要快？

用ArrayList集合，基于数组的。（用的最多）

2.  如果希望元素可以重复，又有索引，增删首尾操作快？

用LinkedList集合，基于链表的。

3.  如果希望增删改查都快，但是元素不重复、无序、无索引。

用HashSet集合，基于哈希表的。

4.  如果希望增删改查都快，但是元素不重复、有序、无索引。

用LinkedHashSet集合，基于哈希表和双链表。

5.  如果要对对象进行排序。

用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。

可变参数

可变参数用在形参中可以接收多个数据。

格式：数据类型...参数名称

作用：传输参数非常灵活、方便。可以不传输参数，可以传输1个或者多个，也可以传输一个数组。在方法内部本质上就是一个数组

注意事项：一个形参列表中可变参数只能有一个且可变参数必须放在形参列表最后面

斗地主游戏的发牌和排牌

Day6 

一、Map集合

Map集合是一种双列集合，每个元素包含两个数据

每个元素的格式 key = value

被称为 键值对集合

 Map集合键无序、不重复、无索引

Map集合特点

Map集合的特点都是由键决定的。

Map集合的键是无序,不重复的，无索引的，值不做要求（可以重复）。

Map集合后面重复的键对应的值会覆盖前面重复键的值。

ap集合的键值对都可以为null。

Map集合遍历

Day7

一、不可变集合

不可变集合就是不可被修改的集合。

集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变，否则报错

为什么要创建不可变集

如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。或者当集合对象被不可信的库调用时，不可变形式是安全的。

二、Stream流

目的：简化集合和数组的操作的API

Stream流式思想的核心：

1.先得到集合或者数组的Stream流（就是一根传送带）

2.把元素放上去

3.然后就用这个Stream流简化的API来方便的操作元素。

Stream流的综合应用

员工类的定义：

优秀员工类定义：

三、异常 

异常是程序在“编译”或者“执行”的过程中可能出现的问题，语法错误不算在异常体系中。

比如:数组索引越界、空指针异常、 日期格式化异常等

编译时异常，是在编译成class文件时必须要处理的异常，也称之为受检异常。

运行时异常，在编译成class文件不需要处理，在运行字节码文件时可能出现的异常。

编译时异常的特点

编译时异常：继承自Exception的异常或者其子类

编译阶段报错，必须处理，否则代码不通过。

编译时异常处理方式

 

运行时异常的处理形式 

运行时异常编译阶段不会出错，是运行时才可能出错的，所以编译阶段不处理也可以

按照规范建议还是处理：建议在最外层调用处集中捕获处理即可。

 自定义异常

可以使用异常的机制管理业务问题，如提醒程序员注意。

同时一旦出现bug，可以用异常的形式清晰的指出出错的地方。

1、自定义编译时异常      

1.定义一个异常类继承Exception.

2.重写构造器。

3.在出现异常的地方用throw new 自定义对象抛出，

作用：编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理。

2、自定义运行时异常

1.定义一个异常类继承RuntimeException.

2.重写构造器。

3.在出现异常的地方用throw new 自定义对象抛出!

作用：提醒不强烈，编译阶段不报错，运行时才可能出现。