黑马程序员技术交流社区

标题: 就业班前六天学习总结: [打印本页]

作者: Stefan_li 时间: 2017-12-14 15:12
标题: 就业班前六天学习总结:
day 01
   1.回顾了基础班所学的知识, 关于数据类型,运算符,方法,数组的定义,应用及注意事项进行了温故;
   2.static,
         特点: ①,被所有对象所共享
                  ②,可使用类名直接调用
                  ③,静态的加载优先于该类的非静态方法和非静态成员变量,随着类的加载而加载;
         *** 根据第③条,就映射出被static修饰的方法不能使用this, 因被static修饰的方法加载优先于非静态成员变量,如果在此时使用this,那么久会造成this 无法找到对应的成员变量,因此时的非静态成员变量还没有加载,
            So, 被static修饰的成员方法不能使用this;
         注意事项: ①静态只能调用静态,不能调用非静态
      原因: 因为静态方法是属于类的，动态方法属于实例对象，动态方法只有在对象实例化之后才存在，如果静态方法能调用动态方法的话，那如果别人通过类名调用静态方法时实例对象可能并不存在，
                  但是方法内又调用了对象的方法，由于对象不存在，所以动态方法也不存在，程序肯定报错,所以java直接在编译阶段检查这种错误，避免运行时异常
               ②非静态可以调用静态,也可以调用非静态

   3.工具类: 构造方法被private修饰的类,简称工具类;防止被创建对象.
                     ① 无法被创建对象, ② 只能使用类名调用类的成员方法;
   4.Math类就是一个工具类,属于一个关于数学计算的工具类
   5.代码块:    ① 局部代码块: 在方法体内
      ② 构造代码块: 随着类的对象创建而加载,优先于构造方法之前,提取构造方法中的共性;
      ③ 静态代码块: 随着类的加载而加载;且只加载一次;静态代码块的加载应用:驱动加载;

day 02
1.继承: 关键字 extends
   定义: 多个类有相同的成员变量和成员方法,需抽取多个类中相同部分的成员变量和成员方法到另外一个类(父类),让多个类去 extends 这个父类,此方法叫做继承;
   特点: ① Java语言只支持单一继承,即一个子类只能继承一个父类
② 为了解决单一继承的局限性;Java继承可以具有多层继承的特性
                     *** 注:一个类如果没有继承任何类,那么他默认继承object类
               成员变量: ① 子类只能继承父类非私有成员变量
      ② 子父类中成员变量名如果在子类没有,直接获取父类的该变量;
                           ③ 强行调用子类成员变量使用this 关键字,强行调用父类成员变量使用super关键字
               成员方法: ① 子类只能访问父类非私有方法;
                           ② 子类没有这个方法,调用父类;子类中有这个方法,使用子类的;称作方法的重写;
      ③ 如果一定要在子类中调用父类的方法;在调用方法的时候加上super;

应用;在同一个行为中,当父类的行为无法满足子类的行为,此时需要对父类的方法进行重写;
   方法的重载 overload:  定义>> 在一个类中,有多个方法名相同,参数列表/参数类型/参数顺序不同;
   方法的重写 override:  定义>> 在子父类当中,当子类的方法声明与父类的方法声明相同(除方法的权限以外),称方法的重写(覆盖);
注:  ① 子类重写父类方法的时候,权限修饰符必须 >= 父类权限修饰符
      ② 在子类中,使用this调用方法,如果子类中没有这个方法,默认调用父类的这个方法;
   构造方法:
      ① 先父类构造方法初始化(先成员变量初始化,再构造方法初始化);再子类构造方法初始化(先成员变量初始化,后构造方法初始化);
         ② 有子父类继承关系中,子类构造方法的第一行,如果没有调用父类的构造方法,则会默认调用父类的无参构造;
         ③ 不管子类构造方法如何调用,第一条输出的肯定是父类构造方法;
               this 和 super的区别:
            this :
                           ① 当前对象的引用;
      ② 调用当前类的方法或成员;
      ③ 可在子类的构造方法第一行调用该类的其他构造方法;
      ④ 调用当前类没有定义的变量时,默认调用父类该变量;
                  Super:
      ① 子类对父类的方法或变量的引用;
            ② 调用父类的构造方法
            ③ super调用构造语句只能放在子类构造方法的第一行中;如在子类构造对象中,没有使用super调用父类构造方法,则默认调用父类构造方法;
                  注: 构造方法中第一行输出的语句只能是super/this,且他两不能同时存在;
               父类有两个东西无法继承给子类
            ① 父类私有化成员/方法
      ② 父类构造方法无法继承;只能通过super访问;
         继承的优点:
         ① 提高代码的复用性;
         ② 提高了可维护性;
         缺点:
   1>.类与类的耦合性变高;
   2>开发原则:高内聚低耦合
   3>.内聚:独立完成事件的能力
   4>.耦合:类与类的关系;
  2.注解:以@开头,写在类/方法上面
@override 方法的重写注解
@overload 方法的重载
3.抽象类: abstract 关键字用于修饰方法和类
抽象方法: 不同类的方法是相似,但是局土内容又不太一样,所以我们只能抽取他的声明,没有具体的方法,
   没有具体的方法体的方法就是抽象方法;
  有抽象方法的类必须是抽象类;
   注:一个子类继承了一个抽象类,必须完善抽象类的抽象方法,如果不完成,子类就必须是个抽象
   abstract 不能与final与private/static共存;

   特点:
  abstract 只能修饰类与方法
  抽象方法只能在抽象类里面
  抽象类和抽象方法必须被abstract修饰;

      抽象类不能创建对象(不能实例化);
  抽象类中可以有非抽象方法;
   抽象类可以被继承,1>.但子类必须去完善抽象类中的抽象方法,
   2>.不然子类必须是抽象类;
4.final修饰符:
  被final修饰的类无法继承;
  被final修饰的变量无法修改,但变量需要赋值;即:被final修饰的变量是一个常量;
  称自定义常量;自定义常量必须初始化;
  被final修饰的方法,无法重写;
  被final所修饰的常量称为自定义常量,一旦被赋值,无法更改;
  注:被final修饰的方法名或常量名都是大写

day 03
  1.接口: interface修饰符
      用于处理继承单一的局限性;
         接口是一个比抽象类还抽象的类,接口里面所有的方法都是抽象方法.
      接口和类的关系是实现,使用implements实现

  格式:
      interface 接口名{ 抽象类方法体 };
      类与接口的关系是实现,一个类使用一个接口,必须实现接口中所有的抽象方法;
  特点:
      ① 接口内部只能有抽象方法;
      ② 接口无法创建对象,因接口是抽象类;
   ③ 只能有常量/自定义常量;
   ④ 默认使用public static final来修饰自定义常量;
注:
   ① 只能使用public&abstract修饰;
         ② 建议手动添加接口方法的修饰符;
  接口内部没有构造方法:因内部没有成员变量,只能有常量,也不能创建对象;

一个方法能定义成static,就定义为static;
   ① 被所有对象所共享;
   ② 可以使用类名直接调用;
   ③ 静态加载优先对象,随着类的加载时候就已经加载;加载于方法区;

  类与类是: 继承关系;单一继承,多层继承.
  类与接口: 实现关系;多实现.
  接口与接口: 继承关系;多继承.

  优点:
   ① 改变了继承的单一继承的局限性;
   ② 对外提供规则和规范;所有方法都经过public所有修饰;
   ③ 降低了程序的耦合性;即提高代码的紧密性;
   ④ 提高了代码的复用性;


2.抽象类和接口的区别:
  共性: 不断的抽取,抽取出抽象的概念;
  区别:
1>. 接口与类的关系: 实现,多实现
      类与抽象类的关系: 继承,单一继承;
  2>. 成员:
   抽象类可以有成员变量;也可以有成员常量;
   接口只能有成员常量.
  3>. 成员方法:
   抽象类可以有抽象方法,也可以有非抽象方法;
   接口只能有抽象方法,默认的修饰符是public abstract

  4>. 构造方法:
   抽象类有构造方法,
   接口没有抽象方法,

3.多态: 前提:子父类关系,方法的写,父类引向子类关系;

  格式:
   父类名变量名 = new 子类名();(此种创建对象的方法可称:向上转型)

  动态绑定:
运行期间,指向右边,调用子类方法;看对象是谁,那就输出谁的方法体;

编译期间,指向左边;

  成员变量: 编译时看左边,运行时看左边.
  成员方法: 编译时看这边,运行时看右边;(调用时,遵循动态绑定.)
  静态方法: 编译时看左边,运行时是左边.(调用时,是用类名的数据类型取调用)


  向上转型: 就是创建子类对象;
  向下转型:`把父类创建的变量强制转换为子类赋值给子类变量;

  缺点: 无法访问子类特有的成员.

  优点: 可以提高可维护性;提高代码的可扩展性;

  补充:判断两个类型是不是同一个类型
  A instanceof B; 表示A是否是B这个类型;

  共性与特性:
   抽象方法/父类基本都是抽取了子类的共性
接口抽取的是子类的特性,其某一部分子类特有的性能,其他子类不具备该性能.
  当方法中传递的参数有子父类的有方法的重载的时候:
如果子类有其独有的方法劲量拆分为方法的重载进行书写;
如果子类中没有其独有的方法,可以使用一个方法,进去后使用instanceof来区分使用;
day 04
1.包: 用于整理/分类区分项目
  特点:
① 多层结构,
② 不同包下的文件名可以重复;
类的全名: 包名.类名
  权限修饰符: 方法类包
public 公共的 √  √ √

default 当前包下使用  √  √ × (不是权限修饰符,表示什么都不写)

private 当前类下  √  × ×
protected 用于子类对象  √  √ ×

① protected权限大于default;
② default只能在当前包类访问,
③ protected可以访问其他包下的父类;
  权限大小:
  public > protected > default > private

  修饰符:  类成员变量       成员方法构造方法
  public √ √    √    √
  protected × √    √    √
  default  √ √    √    √
  private  × √    √    √
  abstract √ ×    √    ×
  static  × √    √    ×

  final  √ √    √    ×
  被final修饰: 不可被继承不可修改不可重写
  常见规则:
常用public修饰类,一个java文件只能有一个类(常用规则),
如果一个类中有多个类,与文件名相同的那个类,必须使用public修饰;
以后所有成员变量使用private修饰
所有方法使用public修饰
所有构造方法使用public修饰
如不想构造方法被访问,使用private修饰;
2.内部内:
  成员内部内;
① 内中,方法外;跟成员方法同意级;
② 内部内可以访问外部内成员变量;包括私有的;
③ 要访问内部内,需对类逐级中访问;,
引用内部内格式
类名.内部内类名
当内部内被对象被static修饰的时候,创建内部内对象的时候,外部内不需要调用方法;
但是内部内对象的方法可以直接被调用;

  局部内部内:
只能在方法内使用
  匿名内部内:
① 可以把匿名内部内看成一个没有名字的局部内部内
② 定义在方法中,必须在定义匿名内部内的时候创建对象;
格式:
new 类名/接口名(){};
原理:创建了继承这个类的子类对象或创建了实现这个接口的子类对象;

day 05
1.Object:
  lang包下的类;
  是根层次结构下的根类,每个类都是用Object作为超类;所有对象(数组)都是都实现这个方法;
  任何类都继承了Object
  String tostring() :  把对象当做字符串返回
返回值类型: String
参数类型: 无参数传递
  应用: 调试的时候使用;
  获取字节码对象 getClass();返回字节码对象
1> 通过对象获取字节码对象
   2> 通过类名调用属性class来获取
3> 通过class类静态方法中forNmae()来获取字节码多谢
  boolean equals(Object o):
比较两对象地址值是否一样;

2.System:

  包含一些有用的类

  static void arraycopy(Object src,int srcPos,Object dest,int desPos,int length);
  复制数组
  Object src 原数组,相当于数组名.
  int srcPos 复制数组中的元素,指定从哪一个索引开始,srcPos表示索引;
  Object dest  表示把src复制哪个数组中去,
  int destPos  表示目标数组的从哪一个索引位子开始接收;
  length    表示目标数组需要接受原数组多少个元素;
  static long currentTimeMillis()
  返回当前系统时间;
3.Date类 ; 在util包下;
  三个子类; Time;Date;

  构造方法:
date(); 创建的是一个表示当前系统时间的Date对象;
date(long);根据指定时间创建date对象;
long是个以毫秒单位的值

毫秒值---->date
设置
返回值 void ,参数 long
void setTime(long time);
date  ----> 毫秒值
获取
返回值 long,无参数
long getTime()

  4.自定义时间格式:
  DateFormat :格式化时间
  SimplDateFormat :
格式化 :
Date 转换 String
String format(Date date)

解析: String 转换 Date
Date parse(String source)
  构造方法:
SimpleDateFormat();
SimpleDateFormat(String pattern)
format()方法输出;
  SinpleDateFormat 日期时间模式:
yyyy :年
MM :月
dd :天
H :时
m :分
s :秒
S :毫秒
"yyyy年MM月dd天 HH:mm:ss"放入创建对象的对象中,  输出的格式就是对象中输入对的格式
  calendar:日历提供了一些年月日时的方法;
  Calendar c =Canlendar.getInstance()
  c.YEAR
  c.MONTH  月是以0开头所以月份需要+1
  c.DATE

5.包装类:  封装了基本数据类型的类;
  integer:被final修饰能在int和String中互转;
String --->int
方法1: intValue()
方法2: static int parseInt(String s)
int  ----> String
方法1:  +""
方法2:  String toString()
方法3: integer.toString();
  构造方法:
Integer(int i)
Integer(String s)
  方法: intValue() 转成字符串

  自动装箱:
Integer i = new Integer(10);
Integer i = 10
  自动拆箱:
int a = i.intValue();
Integer i = 10;
int a = i;

注: int 与integer的区别:
  int 默认值是 0
  integer的默认值是 null
集合存储基本数据类型,也有自动装箱;
math.pow(i,n)  i的n次方
6.正则表达式:
  就是一套规则,可用于匹配字符串;其他很多语言也可以使用该方法;
  boolean matches(String regex)
  判断当前字符串是否匹配正则表达式,匹配成功 true 失败false
  字符:
  字符类
  [abc] a、b 或 c（简单类）
  [^abc] 任何字符，除了 a、b 或 c（否定）
  [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
  [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
  [a-z&&[def]] d、e 或 f（交集）
  [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
  [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

  预定义字符类
  . 任何字符（与行结束符可能匹配也可能不匹配）
  \d 数字：[0-9]
  \D 非数字： [^0-9]
  \s 空白字符：[ \t\n\x0B\f\r]
  \S 非空白字符：[^\s]
  \w 单词字符：[a-zA-Z_0-9]
  \W 非单词字符：[^\w]

  注:切割字符串:
  String [] split(String regex)根据正则表达式匹配拆分此字符串;
String regex 填写正则表达式
连个integer值比较时候,使用equals比较

day 06
1.集合的体系结构:
  由于不同的数据结构(数据的组织,存储方式),所以java提供了不同的集合,
  但是不同的集合他们的功能相似,不断向上提取,将共性提取出来,这就是集合体系结构的形成;
  我们所使用的集合都是最底层的;
  从最顶层开始学习;

  Collection : 集合的顶层;是一个接口;
表示一组对象,有的元素有序,有的元素无序;
无法创建对象,是一个父类接口

  Collection cl = new ArrayList();

boolean add(E e) 添加元素

void clear() 删除元素直接删除整个集合里面所有元素

boolean contains(Object o)  是否包含

boolean remove(Object o) 是否删除成功
boolean isEmpty() 是否为空

int size() 返回元素个数

Object [] obj = cl.toArray() 遍历集合

Object[]数组里面集合索引
与ArrayList 的get()方法,
只因以上是以Collection为父类接口创建的对象,父类里面没有子类的get方法,


  list: 是Collection一个接口;
特点: 有序,有索引, 能存重复的元素;

  set: Collection的子接口;
特点:无序,无索引,不能存重复的元素

  ArrayList:
特点: 添加元素永远成功,因可重复添加元素

集合的遍历方式: 1.toArray()根据数组遍历集合
2.get() 根据索引遍历集合(只实用于List接口下面的所有子父类集合)
3.iterator()可以返回一个迭代器对象,可以通过迭代器对象来迭选集合

2.迭代器: iterator
E next() :返回下一个元素

hasNext() : 判断是否获取到元素;返回boolean类型

  创建对象:
Iterator<String> it =  cl.iterator()
  原理:
是集合的一个父类;迭代器是依赖集合,当迭代器在操作的时候,是不能添加元素的;
解决方案: 在使用迭代器遍历的时候,就可以使用迭代器修改,不适用集合去修改;
寻找子类ListIterator添加元素;

3.并发修改异常:
发生原因: 因使用迭代器的进行遍历的时候,调用集合方法对集合进行数据修改,就会发生并发修改异常;

  解决方法: 使用Iterator的子类 ListIterator的add 方法进行修改;

4.泛型: 集合可以存储任意类型的对象,存储的时候可以一个集合里面存储的类型不一样,
  此冲情况就会报错,所以java对集合就定义了泛型;
   泛型是提前明确了该集合所存储的类型;
  优点: ① 避免类型转换错误
      ② 减少编码区黄色警告
      ③ 简化我们代码的书写
  格式标志: <E>
   所有创建对象的时候看到<E>这样的标志,就表示需要添加泛型;

5.foreach: 增强for循环,一般用于遍历集合或者数组
  格式:for(Object o : 目标变量/集合/数组){};
for(元素的类型变量:集合或者数组对象名){ 可以直接使用变量};
for(object obj:数组名/集合名)
  注:在增强for循环中不能修改集合,否则会出现并发修改异常;

常见遍历:  普通for循环;
   迭代器遍历;

6.数据结构: 数组数据结构: 查找慢,增删快;
链表数据结构: 由链子连接起来的一堆结点;
   结点:
   格式: 该在值地址值,该值,下一个结点地址值

栈: 先进后出; 数据先进来的最后出去,最后进来的最先出去; 进出同口

队列: 先进先出进出不同口

7.List: 有序的;可重复的有索引;
  特有功能:
add 增

get 查
remove 删
set 改

   当integer存储在集合里面是,删除集合元素先定义integer 变量接收集合索引,在用变量当索引去删除;
  List常用子类:
ArrayList: 底层是数据结构,查询卡,增删慢;

LinkedList: 底层结构是链表,查询慢,增删快;
void addFirst(E e)

void addLast(E e)

E getFirst()

E getLast()
E removeFirst()
E removeLast()

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2