A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 暖羊羊 中级黑马   /  2017-12-21 17:27  /  773 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

第二阶段知识点总结



s2-day01

* 静态

        * 关键字: static

        * 作用: 修饰变量, 方法, 类, 被其修饰的成员被所有对象共享

        * 调用静态成员:

                * 调用静态成员变量: `类名.静态成员变量`

                * 调用静态成员方法: `类名.静态成员方法()`

        * 特点

                * 被所有对象共享

                * 直接使用类名调用

                * 静态成员的加载优先于非静态的成员

                * 静态成员的生命周期跟随类的加载而加载, 随着程序的结束而销毁

        * 静态成员变量保存在: 内存中方法区中该类的字节码对象中的静态区域中

        * 静态成员和非静态成员的区别

                * 生命周期不同

                        * 静态成员: 跟随类的加载而创建, 随着程序的结束而销毁

                        * 非静态成员: 跟随对象的创建而创建, 跟随对象的销毁而销毁

                * 内存中的位置不同

                        * 静态成员: 方法区中类的字节码对象中的静态区域中

                        * 非静态成员: 堆内存中对象区域中

                * 初始化时机不同

                        * 静态成员: 类加载时初始化

                        * 非静态成员: 创建对象时初始化

        * 静态方法的调用注意事项

                * 非静态方法中, 可以调用静态和非静态的成员

                * 静态方法中, 只能调用静态的成员

        * 静态方法中能够使用this? 不能, 因为静态和非静态的生命周期不同. 静态方法跟随类加载而加载, 此时不一定有对象, 所以没有this

        * 静态的优缺点:

                * 优点:

                        * 共享数据保存在同一个存储空间中, 节省内存

                        * 可以直接类名调用, 简化代码编写

                * 缺点:

                        * 访问有限制, 静态方法中只能访问静态成员

        * 应用场景:

                * 作为该类所有对象共享的数据

                * 工具类

                        * 把构造方法私有

                        * 所有方法用static修饰, 类名直接调用

* 代码块

        * 概念: `{}`一对大括号引起来的就是代码块

        * 分类:

                * 静态代码块

                        * 定义位置: 类中, 方法外, 前面要加static

                        * 执行时机: 类加载时执行

                        * 执行次数: 只有一次

                        * 作用: 在类加载时进行一些初始化操作

                * 构造代码块

                        * 定义位置: 类中, 方法外

                        * 执行时机: 每次创建对象时执行, 优先于构造方法执行

                        * 执行次数: 创建多少次对象, 就执行多少次

                        * 作用: 抽取构造方法共同执行的代码, 简化书写

                * 局部代码块

                        * 定义位置: 方法中

                        * 执行时机: 调用方法时, 执行到局部代码块则执行

                        * 执行次数: 调用多少次方法能够执行到, 就执行多少次

                        * 作用: 限制局部变量的作用域

                * 同步代码块(多线程讲)


s2--day02

* 继承

        * 概念: 从已有类派生出新的类, 已有类称为父类, 派生类称为子类, 这种子类对父类的关系就是继承

        * 作用: 如果多个类中有共同的成员, 则可以将其抽取到同一个类中, 将这个类作为父类, 让其他类去继承, 继承后子类就具有了父类非私有的成员

        * 关键字: extends

                * 定义位置: 子类类名后, 父类类名前

                * 格式: `public class 子类类名 extends 父类类名 {}`

        * Java语言中继承的特点

                * 支持单继承, 多层继承

                * 不支持多继承

                * 注意: Java中所有类都直接或间接的继承Object类

        * 继承关系下的成员

                * 成员变量

                        * 子类可以获取父类的非私有成员变量

                        * 就近原则:

                                * 如果有局部变量, 则使用局部变量

                                * 如果没有局部变量, 有本类成员变量, 则使用本类成员变量

                                * 如果没有局部变量, 也没有本类成员变量, 则使用父类成员变量

                                * 如果都没有, 报错

                * 成员方法

                        * 方法的重写: 在子父类继承关系中, 子类定义了和父类完全一样的方法(方法声明一样, 方法体无关), 子类就重写了父类的方法

                                * 注解: `@Override`

                        * 方法重写和重载的区别

                                * 定义位置不同

                                        * 重写: 子父类关系中

                                        * 重载: 同一个类中

                                * 方法定义不同

                                        * 重写: 方法声明必须完全一样, 和方法体无关

                                        * 重载: 方法名一样, 参数列表不同, 和返回值, 形参名称, 方法体无关

                        * 重写的特点:

                                * 子类如果重写了方法, 则调用子类重写的方法

                                * 子类如果没有重写父类方法, 则调用父类的方法

                        * 重写的应用场景

                                * 当父类方法无法满足子类需求时, 子类可以重写方法

                        * 注意事项

                                * 父类私有的方法不能重写

                                * 子类重写的方法权限必须大于等于父类方法的权限

               

                       


s2-day03

* 接口

        * 概念: 接口是完全抽象的类, 接口中所有方法都是抽象方法

        * 作用:

                * 扩展功能

                * 弥补Java单继承的局限性, 因为接口可以多实现

        * 使用:

                * 定义接口: `权限修饰符 interface 接口名 {}`

                * 实现接口: `权限修饰符 class 实现类类名 implements 接口名1, 接口名2, ... {}`

        * 成员的特点:

                * 成员变量

                        * 只能是静态常量, 默认使用`public static final`修饰, 即使不写或少写

                * 构造方法

                        * 不能有构造方法

                * 成员方法

                        * 全都是抽象方法, 默认使用`public abstract`修饰, 即使不写或少写

                        * 不能是static的

        * 总结关系:

                * 类和类: 继承关系, 单继承, 多层继承, 不能多继承

                * 类和接口: 实现关系, 多实现

                * 接口和接口: 继承关系, 多继承, 多层继承

        * 优点:

                * 通过多实现打破单继承的局限性

                * 接口可以提供规则

                * 降低程序的耦合性

        * 接口和抽象类的异同

                * 与类的关系不同

                        * 接口: 多实现关系

                        * 抽象类: 单继承, 多层继承

                * 成员变量:

                        * 接口: 只能有静态常量, public static final

                        * 抽象类中: 可以成员变量, 也可以有常量

                * 构造方法:

                        * 接口: 不可以有构造方法

                        * 抽象类: 可以有构造方法, 但不能创建对象, 用于初始化成员变量

                * 成员方法:

                        * 接口: 只能是抽象方法, public abstract

                        * 抽象类: 可以有抽象方法, 也可以有非抽象方法, 也可以没有抽象方法

* 多态

        * 概念: 一个事物有多种形态

        * 前提:

                * 子父类存在继承关系

                * 子类重写父类方法

                * 父类引用指向子类对象


s2-day04

* 包

        * 就是目录

        * 作用: 分类管理Java文件, 避免重名类的冲突

        * 特点: 包可以有多个层级

        * 定义包:

                * 关键字: `package`

                * 格式: `pacakge 包名;`

                        * 多级目录用`.`区分

                * 要求: 包的声明必须在文件第一行

        * 类的全名: `包名.类名`

        * 包的访问规则:

                * 相同包下的类, 直接访问

                * 不同包下的类, 可以导包或使用类的全名



               

       


s2-day05

* Object

        * 是所有类的根类, 所有类默认都直接或间接的继承自它

        * 成员方法:

                * `String toString()`: 返回对象的字符串表示方式

                        * 重写toString()的作用: 改变对象的字符串显示方式

                * `boolean equals(Object o)`: 比较两个对象是否"相等"

                        * Object类中实现方式: `==`, 比较对象的地址值是否相同

                        * 重写equals()方法: 改变比较的规则. 可以直接生成

        * 获取字节码的3种方式

                * `Class 对象.getClass()`

                * `类名.class`

                * `Class Class.forName("类的全名")`

        * 类的字节码对象注意点:

                * 同一个类的字节码对象只有一个, 地址值也是相同的

                * 区分Class和class, 前者是类, 后者是关键字

* System类

        * java.lang包下, 不用导包

        * 常用静态方法

                * `static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int length)`: 复制数组

                * `static long currentTimeMillis()`: 返回当前系统时间的毫秒值, 从1970-01-01 00:00:00

                * `static void exit(int status)`: 终止虚拟机的运行. 传入0是正常退出, 非0是异常退出

* Date类

        * 注意导包: java.util.Date

        * 表示特定的瞬间

        * 构造方法

                * `Date Date()`: 创建Date对象, 并表示当前系统时间

                * `Date Date(long timestamp)`: 创建Date对象, 使用指定的时间

        * 成员方法

                * `String toLocalString()`: (已过时)转换为本地时间格式的字符串

                * `void setTime(long time)`: 设置Date对象的时间

                * `long getTime()`: 获取Date对象中保存的时间毫秒值.

* SimpleDateFormat类

        * 作用:

                * String转Date

                * Date转String

        * 构造方法

                * `SimpleDateFormat(String pattern)`: 创建SimpleDateFormat对象, 并设置指定的格式

        * 常用2个成员方法

                * `String format(Date date)`: 格式化Date对象返回字符串

                * `Date parse(String source)`: 将字符串解析为Date对象

                        * 字符串必须符合模式, 否则抛出异常


* Calendar类

        * 替代Date类

        * 创建对象

                * `static Calendar getInstance()`: 获取日历对象

        * 静态字段: 表示时间的某个部分

                * `Calendar.YEAR`: 年份

                * `Calendar.MONTH`: 月份. 注意月份数值是0-11

                * `Calendar.DAY_OF_MONTH`: 日期

                * `Calendar.HOUR`: 小时(12小时制)

                * `Calendar.HOUR_OF_DAY`: 小时(24小时制)

                * `Calendar.MINITE`: 分钟

                * `Calendar.SECOND`: 秒

        * 成员方法

                * `get(时间字段)`: 获取指定的时间部分

                * `set(时间字段, 指定数值)`: 使用指定数值设置指定的时间部分

                * `add(时间字段, 增加的时间值)`: 根据时间字段的单位增加指定的时间值, 如时间字段是天, 增加n天, 时间字段是秒, 增加n秒. 减少用负数

* 包装类

        * 封装了基本数据类型的类, 提供了更多了方法和变量

        * 把基本数据类型的使用方式转换为面向对象的使用方式

        * 基本数据类型和引用数据类型的对应关系

                * byte: Byte

                * short: Short

                * char: Character

                * int: Integer

                * long: Long

                * float: Float

                * double: Double

                * boolean: Boolean


       

               

s2-day06

* 集合
        * 包含了不同的实现类, 向上抽取出了很多共性的接口, 形成了一个体系结构
* 数据结构
        * 数据的组织和存储方式
* 迭代器
        * 作用: 遍历集合
        * 并发修改异常:
                * 原因: 迭代集合时改变了集合的长度
                * 解决:
                        * 不使用迭代器
                        * 使用迭代器对象中的修改方法














0 个回复

您需要登录后才可以回帖 登录 | 加入黑马