Java笔记总结（二）

类：
  英雄机：x、y、img、height、width、life
  飞行物：x、y、img、width、height、移动
  小蜜蜂：继承 extends 飞行物  速度	移动(斜着)
  敌机：继承 extends 飞行物   速度 移动(向下)
  子弹：继承 extends 飞行物   移动(向上)

主类extends JPanel：主方法
  paint(Graphics g) 绘画
  一个英雄机、分数(生命值)、n个子弹、n个小蜜蜂、n个敌机
  g.drawString   g.drawImage
  
流程：
  1.英雄机跟随鼠标移动
  2.自动发射子弹
  3.移动子弹
  4.敌机小蜜蜂(飞行物)移动
  5.自动生成敌机和小蜜蜂(飞行物)
  6.判断碰撞，消失
  	 判断相撞，就是判断坐标
  	 消失：子弹存在子弹数组中，飞行物存于飞行物数组中
  	 	  让元素从数组中移除出去
  	 	  缩容是移除最后一个元素，将要移除的元素和最后一个元素调换位置
  	 	  Arrays.copyOf(arrays, length + 1)
  	 	  Arrays.copyOf(arrays, length - 1)
  7.小蜜蜂有奖励(要么加生命值，要么加子弹)
  8.敌机碰撞英雄机，减生命值，判断游戏结束
  	 hero.x > fly.x - hero.width
  	 hero.x < fly.x + fly.width
  	 hero.y > fly.y - hero.heigth
  	 hero.y < fly.y + fly.height
  	 
  
持续做的、周期性做的？
	2 3 4 5 6 8

主类：
	属性：1.一个英雄机 2.子弹数组 3.飞行物数组
	静态常量：窗口的宽、高
	静态图片：程序开始时就加载好的
	绘画方法：子方法，画各种东西
	showMe：展示窗口
	主方法：游戏开始
	定时器
 
----------------------------------
思考：FlyObject父类中，step方法不能确定具体的方法实现
	 可以称这个方法为抽象的

static
final
abstract：抽象的
	形容方法：抽象方法，没有方法体{}
	方法是属于类的一个功能
	有抽象方法的类，一定是抽象类
	形容类：抽象类，可以有抽象方法
	不能修饰属性

一个子类继承抽象类，就一定要实现/重写抽象类中的所有抽象方法
抽象类不能直接new对象，但是可以有构造器，提供给子类调用(创建子类时一定会调用父类构造器)

抽象类意义在于被继承

类 class
接口 interface
接口的意义在于被实现，扩展类的功能

JavaSE  JavaEE
JDK中写好的java代码 -> 类/接口
Math\Scanner\System\JFrame\KeyListener

学习类：创建对象(构造器)/成员变量/方法/静态方法

JDK - 核心基础jar包 rt.jar - 工程字节码文件打包
API -> Application Programming Interface 应用程序接口
    -> 帮助文档 doc 
java.lang -> 基础常用 System String Math Thread Object
java.util -> 工具类 Scanner/集合/Date/Calendar
java.text -> 格式化工具 DateFormat
java.io   -> Input Output 文件读写
java.net  -> TCP/IP网络编程 Socket URL


文本编辑器
EditPlus
NotePad ++
Sublime

javac\java\javadoc -> 生成帮助文档
exe4j -> exe文件

测试
1.打桩 System.out.println();
2.单元测试 JUnit - 模块测试
  Test类 - 模拟主方法
3.debug - 断点测试,专业的步骤分析

--------------------------------

Object - 所有类的基类/父类
11个方法, 构造器无

String toString() - 是将对象以字符串形式输出
boolean equals(Object obj) - 判断this和obj是否相等
native int hashCode() - 生成对象的哈希值，内存中的存储位置有关
	默认实现使用C++底层代码, 计算方式-通过内存空间来计算,
	new出得对象, 物理位置都不同，因此每个new对象哈希值都不同
	HashSet/HashMap 会使用哈希值, hashCode() 
	重写的规则：和equals方法一致
	equals判断相等的两个对象，必须保证哈希值一样
	equals判断不相等的两个对象，哈希值尽量不同
Class getClass()
	加载 - 方法区 - 字节码对象
	加载的触发条件：- 类加载器 ClassLoader (反射)
	  实例化对象 new
	  静态方法/静态变量
	  使用子类,父类加载
	  Class.forName("java.lang.String") -- 手动加载指定的类
	  String.class -> 获得类的字节码对象

跟线程有关的方法：
wait()*3
notify()/notifyAll()

Object clone()：浅克隆-复制
	 浅克隆：clone()		- 复制引用
	 深克隆：对象的读写		- 复制对象
	 要求对象是可以克隆的 Cloneable(空) 标记是可克隆的

void finalize() - GC 垃圾回收
	内存泄漏：内存被无效对象占用
	GC：在程序运行时开始启动，不定时回收内存所标记的垃圾
		也可以手动调用GC, System.gc()
	    没有引用的对象，会被内存标记为垃圾
	原则上，Java中是不存在内存泄漏的
	finliaze() 在对象被回收时调用的
	
--------------------------------
String:字符串 - 【不可变的】字符序列(字符数组)
	equals
	hashCode

作业：- 码云
concat
contains
endsWith
indexOf * 4
isEmpty
lastIndexOf * 4
replace
startsWith * 2
substring * 2
trim

Home_Work _ day01
正则表达式 - 预习

选择题：40道 - 学过的
剑指offer：3道

回顾：
  JavaSE 
  API - javadoc - 文档注释/jar
  Object：11个 toString() equals() hashCode()
  		  wait() * 3, notify() nofityAll() - 线程
  		  clone() finalize() getClass()
  类加载：类的字节码信息加载到JVM的方法区中
  		 Class 类型 - 对象 - 一个
  String：字符串 - 字符序列
  		 不可变
  		 字符串常量池
   常用API：
   	 int length()
   	 char charAt(int)
   	 char[] toCharArray()
   	 
  正则表达式	 
   	 [可以选择的选项] - 一个字符
   	 ?  	0或者1次
	 *	 	0或者多次
	 +		1或者多次
	 {n}	恰好 n 次
	 {n,}	至少 n 次
	 {n,m}	至少 n 次，但是不超过 m 次
  	 .		任意字符
  	 \w		单词字符[a-zA-Z0-9_]
  	 \d		数字
  	 \s		空白字符：[ \t\n\x0B\f\r]
  	 
  	 split
  	 replaceAll
  	 
 可变长字符串：改变字符串，不会产生新的对象
 	StringBuffer:所有方法synchronized(锁)
 				安全、效率低
 	StringBuilder:不安全、效率高
 	
 包装类  	
 	基本数据类型 8种 - 包装Object
 	引用类型    Object
    满足一切皆对象
 
  byte  short  int  	long  float  double  char		boolean
  Byte	Short  Integer  Long  Float  Double  Character	Boolean
   
  包装类型数值不可变, 多了 null, 使用上可以无缝切换
  
  int a = 10;
  a = a + 10;
 
java.lang - 基础类String StringBuilder 包装类 线程
java.util - 工具类Date、Calendar、Collection、Map
java.text - 格式化
java.io   - 文件读写
java.net  - 网络编程 TCP/IP
 
java.sql  - 数据库相关
 
	long -> 计时，计算效率，简单的时间计算(7天之内)
	Date -> 显示时间
	Calendar -> 时间推算，时间的跳转
	三种时间格式都可以互相转换
 	
作业：
  day02/day03  -> 码云/GitHub
  牛客网 - 编程题3道
  选择题 - 30道
  
  今晚：选择题 - 30道
  	   day02 -> Test01 ～ Test04 
  
  下周四晚上9点之前剩余内容
  下周六正常上课

：
  String - 正则表达式
  boolean matches(regex)
  String[] split(regex);
  String replaceAll(regex, "newStr");
  
  [0-9]
  \d
  \w - 单词字符 [0-9a-zA-Z_]
  \s - 空白字符
  .  - 所有字符
  次数 ? + * {1} {1,} {1,3}
  \\
  
  java.util.Date 
  	new Date() -> 当前系统时间
  	new Date(long) -> long所对应的时刻的时间
  	
  	boolean before(Date)
  	boolean after(Date)
  	
  	long getTime()
  	void setTime(long)
  	
  	格式化: DateFormate SimpleDateFormat
  		new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
  		String format(Date)
  		Date parse(String)
  时间计算 java.util.Calendar	 - 抽象类
  		static getInstance() - 获得对象
  	字段 Calendar.YEAR  MONTH DATE/DAY_OF_MONTH DAY_OF_WEEK
  	获得时间点	get(字段)
  	设置时间点	set(字段，值)
  	推算时间点	add(字段，改变值)
  		
  	Date  	getTime()/setTime(Date)
  	long	getTimeMillis()/setTimeMillis(long)
  	
   时间格式：long Date Calendar
  		System.currentTimeMillis()
  		new Date()
  		Calendar.getInstance()
  		
----------------------------------------------------
集合：可变长的数组
数据结构：顺序结构、链表（链式结构）
 	1.顺序结构：按顺序排列，每个元素都是带标号
 			除了标号是连续的，内存中的物理空间也是连续的
 			底层使用数组实现 -> 集合功能
 	
 	顺序结构的集合：-> 可扩容的数组
 		 存储数据 list.add(object)
 		 获得数据
 		 删除数据
 		 修改数据
 	
 	优点：查询速度很快
 	缺点：插入/删除速度很慢，需要连续的物理空间，空间使用率低
 	
 	2.链式结构：线性，空间不连续，没有标号，只有头节点
 			底层实现：节点(数据+下一个节点的引用)
 			所有节点的访问，只能从头节点开始
 			头节点：只有next，没有数据的
 			空链表，head.next = null
 	单向链表：Node-next,只能从head开始往下寻找
 	双向链表：Node-next/pre，可以从head，还可以从foot开始
 			head：不存元素，只有next
 			foot：不存元素，只有pre
 			JDK -> LinkedList
 	循环链表：尾节点指向头节点
 	
 	优点：插入/删除速度快，不需要连续的物理空间，空间利用率高
 	缺点：查询效率极低
 	
 	总结：顺序结构+链式结构，-> 线性结构(固定顺序)
 	
 	3.树状结构 -> 二叉树
 	
 	4.栈、队列、双端队列 -> 线性结构(顺序固定)
 		数组 节点 方式实现
 	
 	5.散列表 -> 无序 -> 哈希值 hashCode()

Java中的单位：类Class、接口Interface、枚举Enum、注解Annotation、数组
Java中的数据结构的实现 -> 集合 java.util
				Collection(集合-I)
						|
		List(I)			Set(I)			Queue(I)
		  |				  |					|
		ArrayList(C)	SortedSet(I)	  Deque(I)
		LinkedList(C)	  |- TreeSet(C)	  LinkedList(C)
		Vector(C)	    HashSet(C)
					
作业：
  1.Collection -  List - ArrayList/LinkedList
	迭代器跳过，自学，并且完成day04
  2.MyArrayList/MyLinkedList 完善

  今晚上传：MyArrayList/MyLinkedList
		  day04: test01～test03


 	
 	
 	

回顾：
  Collection：toArray() toArray(new String[0])
  			  iterator() -> foreach
  List:ArrayList/LinkedList/Vector
  	   增删查改 和 下标/索引 有关的方法
  	   add(index, obj)
  	   remove(index)
  	   get(index)
  	   set(index, obj)
  LinkedList:双向链表 first last
  
-------------------------------
Queue：队列(先进先出)  线性结构(顺序结构、链表、队列、栈)
	LinkedList
	只有顺序，没有标号
	
线性结构：
   顺序结构：物理空间也是连续的，有标号的
   链表结构：物理空间不连续，只有头/尾节点
   队列结构 - 双端队列，没有标号，实现通过顺序/链表实现
   栈：实现通过顺序/链表实现
散列结构：不连续、没有顺序
	Set -> 截取 Map(映射表)
	HashSet -> 不允许重复，equals方法判断是否重复
			   内存存储位置，由hashCode值决定(进行的哈希算法)
	HashSet存储过程：
		1.调用自身的hashCode()方法计算存储位置
		2.如果位置上没有元素，直接存入
		3.如果位置上有元素，再调用自身equals方法和该位置上的元素比较
		4.如果比较不一致，另计算位置存入(重复上面)
		5.如果比较一致，不存入

树状结构：二叉树 排序 中序遍历，由小到大排序
	Set -> SortedSet -> TreeSet
	Tree存储过程：Comparable
		1.和根节点比较 —- 通过compareTo方法比较
		2.如果比根节点大，存储在右边
		3.如果比根节点小，存储在左边
		4.如果一样大，不存入
	
作业：
	1.笔记整理到CSDN
	2.刷题30道选择题，编程题2个 -- 周六晚检查
	3.day05 - 必做1～3，4、5（自学并尝试）- 周四之前