题目链接

计算最大利润（在约束条件下）：

• 不能同时参与多笔交易（必须在再次购买前出售掉之前的股票）
• 卖出股票后，无法在第二天买入股票（冷冻期为一天）

方法

这道题是最近遇见最难处理的一道DP题。

我们可以试想对于每一天的i，都有可能是三种状态：

1. 不持股且当天没有卖出$dp[i][0]$;
2. 持股$dp[i][1]$;
3. 不持股且当天卖了$dp[i][2]$;

初始化：

$dp[0][0]$ = 0;

$dp[0][1]$ = -prices[0];

$dp[0][2]$ = 0;

分析：

第i天不持股且没有卖出，所以有两种可能：

1. i-1天不持股且当天没有卖出

2. i-1天不持股但是当天卖出去了

   所以： $dp[i][0]=max(dp[i-1][0],dp[i-1][2])$

第i天持股，也有两种可能：

1. 昨天持股，今天继承昨天的

2. 昨天不持股，今天买入。这里的前提是昨天一定没有卖，如果卖了则今天就无法交易了

   所以：$dp[i][1]=max(dp[i-1][1],dp[i-1][0]-p[i])$

第i天不持股且当天卖出了 == $dp[i][2]=dp[i-1][1]+p[i]$

最后一天的最大收益有两种可能，而且一定是“不持有”状态下的两种可能，把这两种“不持有”比较一下大小，返回即可

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution {
    public int maxProfit(int[] prices) {
        int n=prices.length;
        if(n<=1) return 0;
        int [][] dp = new int[n][3];
        dp[0][0]=0;
        dp[0][1]=-1*prices[0];
        dp[0][2]=0;
        for(int i = 1; i < n; i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][2]);
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0] - prices[i]);
            dp[i][2] = dp[i-1][1]+prices[i];
        }
        return Math.max(dp[n-1][0],dp[n-1][2]);
    }
}       

可能在调剂后，心里都并没有多难受，但是现在我想这份遗憾真的可能要伴随我两年了，但是我更希望自己能做出改变，让它最好只有一年，而不是几年后的哪一天还会想起今天的遗憾，当然更想的是提升自己的能力和内涵，做自己想做的那一个优秀的自己。

数组：

所有元素都连续的存储于一段内存中，且每个元素占用的内存大小相同。这使得数组具备了通过下标快速访问数据的能力。
但连续存储的缺点也很明显，增加容量，增删元素的成本很高，时间复杂度均为 O(n)。增加数组容量需要先申请一块新的内存，然后复制原有的元素。如果需要的话，可能还要删除原先的内存。删除元素时，需要移动被删除元素之后的所有元素。

• 优点：可以根据偏移实现快速的随机读写。
• 缺点：扩容，增删元素极慢。

参考链接

友链

娱乐板块

字数统计

评论

参考博主伍尔夫的猫的博文如何通过Python自动完成移动校园“每日健康”打卡和博主CookiePie的文章Python—利用Requests实现每日微信自动打卡，拿来主义可耻，所以还是自己写一篇博客记录一下解决问题的过程，主要是为了学习，顺便激励自己好好写论文，坚持写代码，早日去实习。

一、前期准备

1、抓包

不细说了，安装Fiddler或者在浏览器端的话直接用谷歌开发者工具。(我是在浏览器端完成的，小程序端会复杂些)

2、安装selenium

我用的也是Pycharm，参考这个博主的Python配置Selenium+Chrome环境和Selenium+PhantomJS环境

3、配置Phantomjs

如果参考上面安装过程中测试代码没有问题就可以跳过了

1

driver = webdriver.Chrome()

如果会报错，那么奖励你，继续看Python配置Selenium+Chrome环境和Selenium+PhantomJS环境，其中，第5点说明了无界面的浏览器包PhantomJS的应用。如果还会报错，可以将selenium的版本修改为了selenium2.48.0版本，亲测可以。

代码

代码参考了原博主的，然后根据学校的网站进行抓包分析，思路和原博主基本上是一致的。

1. 抓包分析
2. 模拟登录
3. 伪装Header发送Cookie，data

但是!!!，正是由于抓取的post包里面有Authorization，

并且它还是刷新的，如果Header中没有授权码，则服务器默认收到的是非法数据。所以耗费了一天时间才搞定。所以重点记录解决这个问题的思路，因为我看的好几篇博客并没有遇见这个问题，只需要Cookie和User-Agent就可以了。

直接说Authorization，先读读这个权限认证基础:区分Authentication,Authorization以及Cookie、Session、Token ，说实话我这个菜鸡开始也不是很懂，不过看见这个，那没事了。

也就是说我们需要去找到服务端返回给客户端的token，也就是刷新的Authorization。所以

1. 找到它

2. 获取并使用它

3. 更新它

   那么我们已经在包里面找到它了，但是实际上还是没有找到它…因为我们需要将它的值获取到且随着它更新，而不是复制出来。

那么到这里，我当时有两个思路：

1. 我有一个大胆（笨比）的想法，就是webdriver.Chrome()既然是模拟浏览器操作，那么我们

   • 模拟登录后，得到新的网页
   • 然后点击“健康打卡”又可以进入打卡界面
   • 终于只需要点击上报就ok啦！ 这不是有手就行！？ 然后我写了如下代码：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   driver = webdriver.Chrome() driver.maximize_window() driver.get(url_) driver.find_element_by_xpath('//*[@id="username"]').send_keys(user_['name']) driver.find_element_by_xpath('//*[@id="password"]').send_keys(user_['password']) driver.find_element_by_xpath('//*[@id="loginForm"]/div[4]/button').click() sleep(2) cookie_ = driver.get_cookies()[0] print(driver.current_url) sleep(1) driver.switch_to.window(driver.window_handles[0]) el = driver.find_element_by_xpath('//*[@id="my-apps"]/li[3]') ActionChains(driver).move_to_element(el).perform() #鼠标移动到该元素停留 sleep(2) buttonElement = driver.find_element_by_xpath('//*[@id="my-apps"]/li[3]/a/div[2]/p[2]/span[1]') ActionClick = ActionChains(driver).click(buttonElement) ActionClick.perform() frame1 = driver.find_element_by_id("iframe") # 切换到iframe1这个内嵌网页 driver.switch_to.frame(frame1) ActionChains(driver).move_by_offset(843, 100).click().perform() # 鼠标左键点击， 200为x坐标， 100为y坐标 sleep(3) driver.quit() return cookie_['name'] + '=' + cookie_['value']

   首先简简单单的就到了第二步，准备点击健康打卡，结果tmd它不是button，没办法click()，而且只有鼠标在这个模块上放一秒，它才会出现进入这个元素。所以我机智的（暴力的）通过强大的driver模拟了这一操作过程。终于，到了最后一步了，只需要点击新出现弹窗里面的“进入”就可以了，结果tmd(真的忍不住)这个弹窗就很神奇，它的元素是定位不到的！(试了很多解决方法不行)无奈之下，想到了我的老本行——暴力，把鼠标移动到这个“进入”的坐标位置点击左键即可。然后用snipaste截图测位置测了半天没找到，只能放弃。

2. 暴力无奈之下，只能另寻他路。结果突然发现这个Authorization就是token，并且它还保存在sessionStorage里面，真的得来全不费功夫。真的需要认真读文档和博客，而不是自己瞎弄。后面就是打开切换到这个内嵌iframe上，然后获取到token值，这样就解决问题了。代码如下：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

   import requests import json from selenium import webdriver from time import sleep from selenium.webdriver.common.action_chains import ActionChains def get_cookie(url_, user_): list = [] driver = webdriver.Chrome() driver.get(url_) driver.find_element_by_xpath('//*[@id="username"]').send_keys(user_['name']) driver.find_element_by_xpath('//*[@id="password"]').send_keys(user_['password']) driver.find_element_by_xpath('//*[@id="loginForm"]/div[4]/button').click() sleep(1) cookie_ = driver.get_cookies()[0] sleep(1) driver.switch_to.window(driver.window_handles[0]) el = driver.find_element_by_xpath('//*[@id="my-apps"]/li[3]') ActionChains(driver).move_to_element(el).perform() sleep(1) buttonElement = driver.find_element_by_xpath('//*[@id="my-apps"]/li[3]/a/div[2]/p[2]/span[1]') ActionClick = ActionChains(driver).click(buttonElement) ActionClick.perform() frame1 = driver.find_element_by_id("iframe") # 切换到iframe1这个内嵌网页 driver.switch_to.frame(frame1) sleep(1) token = driver.execute_script('return sessionStorage.getItem("token");') driver.quit() list.append(cookie_['name'] + '=' + cookie_['value']) list.append(token) return list user = {'name': '账号', 'password': '密码'} list = get_cookie( 'http://my.lzu.edu.cn:8080/login?service=http://my.lzu.edu.cn', user) ##网页打卡入口 headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36', 'Authorization': list[1], 'Cookie': list[0] } data = { 'bh': 'xxxxxxxxxx', 'xykh': 'xxxxxxxx', 'twfw': 0, 'jkm': 0, 'sfzx': 1, 'sfgl': 0, 'szsf': '', 'szds': '', 'szxq': '', 'sfcg': 0, 'cgdd': '', 'gldd': '', 'jzyy': '', 'bllb': 0, 'sfjctr': 0, 'jcrysm': '', 'xgjcjlsj': '', 'xgjcjldd': '', 'xgjcjlsm': '', 'zcwd': 0.0, 'zwwd': 0.0, 'wswd': 0.0, 'sbr': 'xxx', 'sjd': '', 'initLng': '', 'initLat': '', 'dwfs': '' } ##= 这个就是抓取的Post包的data，更新自己的数据信息 url = 'https://appservice.lzu.edu.cn/dailyReportAll/api/grtbMrsb/submit' ##提交信息时候的php key = 'Server酱的key' try: s = requests.session() response = s.post(url=url, headers=headers, data=data) html = response.text except: url = 'https://sc.ftqq.com/%s.send?text=登录页访问超时，打卡失败' % key requests.get(url) if json.loads(response.text)['message'] == '成功': #url = 'https://sc.ftqq.com/%s.send?text=自动打卡成功' % key #requests.get(url) else: url = 'https://sc.ftqq.com/%s.send?text=自动打卡失败' % key requests.get(url)

   最后就是用Windows任务计划程定时调用执行Python脚本

   还用了Server酱来提示打卡成功和打卡失败，over！

面向对象

面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

封装，继承，多态

类是对一类事物的描述，是抽象的、概念上的定义

对象是实际存在的该类事物的每个个体，因而也称为实例（instance）

属性=成员变量=field=域、字段

方法=成员方法=函数=method

创建类的对象=类的实例化=实例化类

局部变量没有默认初始化值

重载：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

可变个数形参的方法：

数据类型 … 变量名

可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。

可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。

可变个数形参在方法的形参中，必须声明在末尾。

可变个数形参在方法的形参中，最多只能声明一个可变形参。

2. 变量赋值：

   基本数据类型：此时赋值的是变量所保存的数据值。

   引用数据类型：此时赋值的是变量所保存的数据的地址值

• 【Hexo异常】fatal: in unpopulated submodule ‘.deploy_git’

• Window下完全卸载删除Nodejs

• nvm安装（Windows篇)https://www.jianshu.com/p/13c0b3ca7c71

如果先安装node，再安装nvm，可能会出现修改后，版本仍然未变的情况，尝试了网上很多方法，建议还是卸载重新安装降低版本的node.js

从一台电脑上迁移至另外一台电脑

实现步骤

• 复制blog文件夹
• 在新的电脑上下载新的git和nodejs
• npm install
• 安装hexo,重新部署。

  问题

  1.nodejs版本过高

  下载低版本13.14。

  2.Please make sure you have the correct access rights and the repository exists.（一般是公钥出问题）

1. git config –global user.name “你的GitHub用户名”
   git config –global user.email “你的GitHub注册邮箱”

2. 删除.ssh文件夹（直接搜索该文件夹）下的known_hosts(手动删除即可，不需要git）

3. 生成ssh密钥文件：

   ssh-keygen -t rsa -C “你的GitHub注册邮箱”

4. 打开GitHub_Settings_keys 页面，新建new SSH Key，把密钥复制上去。

   3.遇见404问题

   参考解决方法

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import re
f = open("C:/Users/张金元/Desktop/a.txt", "r", encoding='utf-8')     #打开a.txt文件，以只读得方式，注意编码格式，含中文
data = f.readlines()                            #循环文本中得每一行，得到得是一个列表的格式<class 'list'>
f.close()                                       #关闭a.txt文件
for line in data:
    result = re.findall('-(\w*\w)\s+',line)     #使用正则表达式筛选每一行的数据,自行查找正则表达式   取得后缀
    result1 = list(set(result))          #去掉重复后缀
    result1.sort(key=result.index)       #按照之前的list排序
    print("res1:%s" % result1)
for i in result1:
    f1 = open("C:/Users/张金元/Desktop/c.txt", "a+", encoding='utf-8')          #新建一个c.txt文本，已追加的方式写入
    f1.write(i + '\n')  # 将每一行打印进c.txt文件并换行
    f1.close()  # 关闭c.txt文件**
    print(i)

python txt操作

• 打开文件：f = open(“test.txt”, ‘操作模式’) #”test.txt”文本操作路径
• w ——————————– 只能写入，如果之前有文件，则会被覆盖
• r ——————————– 只能读取
• a ——————————– 向文件追加
• w+ ——————————– 可读可写
• r+ ——————————– 可读可写
• a+ ——————————– 可读可追加
• wb+ ——————————写入进制文件

  正则表达式

  语法

• . 匹配任意字符（不包括换行符）
• ^ 匹配开始位置，多行模式下匹配每一行的开始
• $ 匹配结束位置，多行模式下匹配每一行的结束
• * 匹配前一个元字符0到多次
• + 匹配前一个元字符1到多次
• ? 匹配前一个元字符0到1次
• {m,n} 匹配前一个元字符m到n次
• \\ 转义字符，跟在其后的字符将失去作为特殊元字符的含义，例如\.只能匹配.，不能再匹配任意字符
• [] 字符集，一个字符的集合，可匹配其中任意一个字符
• | 逻辑表达式 或 ，比如 a|b 代表可匹配 a 或者 b
• (…) 分组，默认为捕获，即被分组的内容可以被单独取出，默认每个分组有个索引，从 1 开始，按照”(“的顺序决定索引值
• (?iLmsux) 分组中可以设置模式，iLmsux之中的每个字符代表一个模式,用法参见 模式 I
• (?:…) 分组的不捕获模式，计算索引时会跳过这个分组
• (?P…) 分组的命名模式，取此分组中的内容时可以使用索引也可以使用name
• (?P=name) 分组的引用模式，可在同一个正则表达式用引用前面命名过的正则
• (?#…) 注释，不影响正则表达式其它部分,用法参见 模式 I
• (?=…) 顺序肯定环视，表示所在位置右侧能够匹配括号内正则
• (?!…) 顺序否定环视，表示所在位置右侧不能匹配括号内正则
• (?<=…) 逆序肯定环视，表示所在位置左侧能够匹配括号内正则
• (?<!…) 逆序否定环视，表示所在位置左侧不能匹配括号内正则
• (?(id/name)yes|no) 若前面指定id或name的分区匹配成功则执行yes处的正则，否则执行no处的正则
• \number 匹配和前面索引为number的分组捕获到的内容一样的字符串
• \A 匹配字符串开始位置，忽略多行模式
• \Z 匹配字符串结束位置，忽略多行模式
• \b 匹配位于单词开始或结束位置的空字符串
• \B 匹配不位于单词开始或结束位置的空字符串
• \d 匹配一个数字， 相当于 [0-9]
• \D 匹配非数字,相当于 [^0-9]
• \s 匹配任意空白字符， 相当于 [ \t\n\r\f\v]
• \S 匹配非空白字符，相当于 [^ \t\n\r\f\v]
• \w 匹配数字、字母、下划线中任意一个字符， 相当于 [a-zA-Z0-9_]
• \W 匹配非数字、字母、下划线中的任意字符，相当于 [^a-zA-Z0-9_]

###
正则表达式以及group的用法

• 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class Solution {
    public String replaceSpace(StringBuffer str) {
    String str1 = str.toString();
        if(str1.equals(""))
        {
            return(str1);
        }
        char [] strArray = str1.toCharArray();
        int lengthSpace = 0;
        for(int i = 0;i<strArray.length;i++)
        {
            if(strArray[i]==' ')
            {
                lengthSpace++;
            }
        }
        int newStrLength = strArray.length + lengthSpace*2;
        char [] newstrArray = new char[newStrLength];
        int count = 0;
        for(int i = 0;i<strArray.length;i++)
        {
            if(strArray[i]!=' ')
            {
                newstrArray[i+count*2] = strArray[i];
            }
            else{
                newstrArray[i+2*count]='%';
                newstrArray[i+2*count+1]='2';
                newstrArray[i+2*count+2]='0';
                count++;
            }
                
        }
        return new String(newstrArray);
    }
}

1
2
3
4
5

public class Solution {
public String replaceSpace(StringBuffer str) {
return str.toString().replaceAll("\\s", "%20");
}
}

题解：如果建新数组的话，从后往前还是从前往后都是一样的。???

1. charAt(),deleteCharAt()

   s1.charAt(3);
   s1.deleteCharAt(3);

2. setCharAt();
   替换所引出的char值

   str.setCharAt(indexnew, ‘0’);

3. append();

   StringBuffer s1 = new StringBuffer().append(“bbb”);
   s1.append(“aaa”);
   System.out.println(s1.toString());

4. replace两种用法：

   replace(int start，int end, String str)
   replace(char oldchar, char newchar)

5. toString() toCharArray()

   StringBuffer s1 = new StringBuffer();
   s1.toString();
   String s2 = new String();
   s2.toCharArray();

6. delete(); insert(); indexOf(); lastIndexOf(); reverse(); length();
   indexOf()返回指定字符串的开始字符索引位置，还可以从某个字符索引位置开始向后匹配，没有找到匹配的就会返回-1
   lastIndexOf()是从后往前匹配，也支持从指定索引开始从后往前去匹配

   s1.delete(2,4);
   s1.insert(2,”cc”);
   System.out.println(s1.indexOf(“ba”));
   System.out.println(s1.indexOf(“ba”,2));
   System.out.println(s1.reverse());
   System.out.println(s1.length());

7. String,StringBuffer,StringBuilder三者的使用方法和区别
   String适用于少量的字符串操作的情况
   StringBuilder适用于单线程下在字符缓冲区进行大量操作的情况
   StringBuffer适用多线程下在字符缓冲区进行大量操作的情况

6. 一.java数据类型
7. 基本数据类型
   byte(1) boolean(1) short(2) char(2) int(4) float(4) long(8)double (8)
8. 引用数据类型
   string,数组，集合ArrayList,Scanner,Random,自定义类型
9. 引用类型String中的方法
   第一组：判断方法
   boolean equals(String str); //比较两个字符串是否相等
   boolean equalsIgnoreCase(String str); //比较两个内容是否相等 （忽略大小写）
   boolean startsWith(String subStr); //判断某个字符串是否以指定的子串开头
   boolean endsWith(String subStr); //判断某个字符串是否以指定的子串结尾
   第二组：获取方法
   int length();//获取字符串中字符个数
   char charAt(int index); //获取字符串中某一个字符
   String substring(int startIndex);//从指定下标开始截取字符串，直到字符串结尾
   substring(int startIndex,int endIndex); //包括开头不包括结尾？
   int indexof(String subStr); //获取子串第一次出现的下标
   第三组：转换方法
   String toLowerCase(); //转成小写串
   String toUpperCase); //转成大写串
   Char[] toCharArray(); //变成字符数组
   第四组：其他方法
   String trim();//去掉字符串两端的空格
   String[] split(String str); //切割字符串
   三：读写文件
   输出流：数据从java程序 到 文件中
   FilWriter：文件的字符输出流，写数据 （一个字符，一个字符串，一个字符数组）
   write(int ch);// 写一个字符
   write(char[] chs); //写一个字符数组
   write(String s);// 写一个字符串
   write(char[] chs,int startInex,int len);// 写一个字符数组的一部分
   write(String s,int startInex,int len); //写一个字符串的一部分
   输入流：数据从文件 到 java程序中
   FileReader:文件的字符输入流,读数据（一个字符，一个字符数组）
   int read();//读取一个字符 ASCII
   int read(char[] chs); //一次读取一个字符数组，返回值是读取的字符的个数
   文件的路径分为两种：
10. 相对路径：

      相对于当前项目而言的

11. 绝对路径：

      以盘符开头

 接口作用：天生作为“父接口”

 //成员变量，不能定义普通的成员变量 //成员方法：必须都是抽象 public abstract 返回值类型 方法名();

 如果是类与类  不支持多继承  只支持多层继承 如果是接口和接口  支持多继承  也支持多层继承

 只有类 实现接口

 否则 这个实现类 还是一个抽象类，是不能创建对象的 在开发中最常用的模式：     public class A extends AbstractClassB implements 接口A，接口B{         注意：         A中必须重写 抽象类中的抽象方法，以及所有接口中的抽象方法     } 

7.面向对象3大特征：封装(安全性)，继承(扩展性)，多态(灵活性)
多态：
前提1.必须有子父类关系
2.必须有方法的重写
多态在Java中的表现形式：
父类类型 变量名 = new 子类类型();
接口类型 变量名 = new 实现类();
Animal an = new Cat();
父类类型的变量指向了子类的对象
注意：
1.使用多态调用成员变量
编译时，看父类
运行时，看父类
2.使用多态调用成员方法
编译时，看父类
运行时，看子类
总结：
弊端：多态只能调用子父类共有的方法，不能调用子类特有的方法
好处：提高灵活性
父类类型的变量，可以接收任何一个子类的对象
调用方法的时候，编译是看父类，运行时运行的传递过来的子类对象的方法
弊端的解决方案：
向下转型：强制类型转换
向上转型：自动类型转换 (就是多态)
向下转型也有弊端：
把父类的变量 转成任何子类类型时候，编译器直接通过
可以转成cat,本质是dog 所以出错
Java中解决向下转型弊端的方法：
一个关键字Instanceof 运算符
作用：判断某一个变量 不是 该类的类型
格式：
boolean b = an instanceof 类名
多态提高程序的灵活性，扩展性，复用性。

7. static的介绍:
   static的作用用来修饰类中的成员
   1.如果一个类的成员被static修饰了，怎么访问？ 类名.成员变量名
   存在方法区中的静态区，只有一个空间 优先于对象存在
   2.类名.成员变量(推荐) 对象.成员变量 都可以
   3.所有对象共有的，被staic修饰的成员属于类，不属于单个对象
   4.静态没有多态性 静态不属于对象，属于类
   5.静态代码块：

    在类的成员位置     static{         代码     }

   特点：
   使用到这个类时，JVM会自动执行静态代码块
   只会第一次使用时执行
   优先级比构造方法高，比main方法高
   作用：用来初始化类的,myswl数据(静态代码块来加载驱动)

8. final可以修饰
   类，成员变量，成员方法，局部变量(基本类型，引用类型)
   1.修饰类(太监类)，不能被继承
   2.final修饰成员变量:

    2.1必须在创建对象之前有却确定的值 2.3只能赋值一次

   3.修饰方法:

    不能被子类重写

   4.修饰基本类型局部变量

    被final修饰的基本类型局部变量  只能赋值一次

   5.修饰引用类型局部变量

    被final修饰的引用类型局部变量  只能赋值一次 但是引用类型所指向的对象中内容是可以改变的

9. 匿名内部类：是一种特殊的语法，用来快速创建抽象类的子类对象

            用来快速创建 接口的实现类对象

   AbstractAnimal an1 = new AbstractAnimal(){

    重写

   }
   多态

10. 引用数据类型
    a.类作为方法的参数或者返回值(我们需要传递或返回的是该类的对象)
    b.抽象类作为方法的参数和返回值 (和9结合起来)我们需要传递或返回的是该抽象类的子类的对象
    c.接口作为方法的参数和返回值 (我们需要传递或返回的是该接口的实现类的对象)

11. 链式编程

12. 权限修饰符
    如果一个成员只想在本类中使用 用private修饰
    如果一个成员想在本类和本包的其它类中使用 不写 default
    如果一个成员想在本类，本包，其他包的子类中使用 用protected修饰
    如果一个成员想在所有类中使用 用public修饰

13. Object类：
    类Object是类层次结构的根类
    所有类都必须直接或者间接的继承object

    1. boolean equals(Object obj);
       p1.equals(p2);
       //比较两个对象是否相等,在Object类中定义equals方法比较是 两个对象的地址
       在String类中 重写了object父类中的equals方法，
       本来在object类中比较的是两个对象的地址
       在String重写后变成比较两个字符串的内容

    我们程序员 通常自定义一个类 也会重写equals

    2. toString(); //返回该对象的字符串表示
       Object类中的默认的返回值：包名.类名@地址
       实际开发中toString的使用，重写toString 返回对象中的成员变量

14. 异常:是java代码编译或者运行过程中
    异常的继承体系:
    Throwable(异常和错误的超类):可以抛出去的东西

    --Exception:异常(普通问题) --编译时异常:  指的是Exception 以及Exception子类  (除了RuntimeException)--运行时异常:  RuntimeException以及其子类--Error:错误(严重问题) 比如:OutOfMemoryError:超出内存错误如果程序出现了错误，只能改代码

    创建异常对象，对异常的基本操作：
    1.抛出异常 2.处理异常(捕获异常，将异常获取，使用try/catch做分支处理)
    JVM默认处理异常的方式:(中断处理)
    处理异常的方式：
    1.不处理

    public 返回值类型 方法名(参数)throws xxxException{}

    2.捕获处理

    try{    可能出现的异常的代码}catch(Exception e){    //处理异常}finally{    //写上必须要执行的代码    //释放资源的代码}

    3.其他的处理方式

    多个异常分别处理多个个异常一次捕获多次处理多个异常一次捕获一次处理

    父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理。
    打印异常信息:printStackTrace
    1.RuntimeException
    2.ClassCastException 类型转换异常(向下转型的时候)
    3.ArrayIndexOutOfBoundsException 数组下标越界
    4.StringIndexOutOfBoundsException 字符串下标越界
    自定义异常类：
    1.创建一个类，这个类必须用Exception结尾
    2.必须继承Exception 或者 RumtimeException
    3.自定义的异常 至少有两个构造

    a.空参数构造b.带有String类型参数构造

15. Object类:是所有类的根类
    boolean equals(Object obj)
    a.Object类中equals方法,比较是两个对象的地址，就是==号的作用
    b.重写 比较两个字符串的内容 比较两个对象的成员变量的值
    String toString();//返回该对象的字符串表示 hashCode()返回该对象的数字表示

16. 什么叫设计模式？
    把解决问题的方案 总结出一个套路

17. 代理设计模式
    1.1静态代理设计模式
    1.2动态代理设计模式

18. date类:日期类

    表示特定的瞬间，精确到毫秒

    public Date(); //无参构造
    public Date(long time);
    1.DateFormat是一个抽象类 我们不能用它
    2.我们使用它的一个子类：SimpleDateFormat
    SimpleDateFormat:简单的日期格式化类
    1.构造

    public SimpleDateFormat(String pattern);//以指定的模式 创建一个日期格式化对象

    2.成员方法

    public String format(Date d);//格式化一个日期对象，返回格式化后的一个字符串public Date parse(String s);//把一个字符串形式的日期，解析成Date对象

19. Calender类
    获取Calendar的子类对象
    获取Calender对象的某个字段 (get)

20. System类
    它不能被实例化，因为构造方法私有化了
    而且System类中的方法都是静态的，通过类名就可以直接访问
    System.exit(0); //退出JVM
    public static void gc(); //运行java的垃圾回收器(并不是马上运行)
    public static String getProperty(String ProertyName);//获取某一个属性的值
    public static long currentTimeMillis();//获取当前系统的毫秒值

21. String(不可变) StringBuilder(可变)
    //当出现大量的字符串拼接运算 时 用StringBuilder

22. 基本数据类型 对应的引用类型
    int Integer
    拆箱：包装类型—>基本类型
    装箱：基本类型—>包装类型

23. 正则表达式：

25. javac 生成编译文件

26. java 执行类文件，出错原因java程序运行class文件,对于有包名的类,java把包名当成文件夹处理.”包名+类名”相当于”文件夹目录+类名”来寻找类。

27. b = a++ a先赋值，再自增。

28. mysql Orcale DB2(银行系统) SQLite(手机端) SQLServer SyBase(建模工具PowerDesigner)

失败不是终点，找好工作再说8

指令系统

数据寻址方式:

• CPU:

1. 立即寻址方式
2. 寄存器寻址方式

• 存储器：

1. 直接寻址方式
2. 间接寻址方式
3. 相对寻址方式

• IO流
  1.字符流,字节流
  字符输入流：共同的父类Reader 比如FileReader,BufferedReader

    功能：读取一个字符，读取一个字符数组(一部分)，读取一个字符串

  字符输出流：共同的父类Writer 比如FileWriter,BufferedWriter

    功能：写一个字符，写一个字符数组(一部分)，写一个字符串

  字节输入流：共同父类 InputStream 比如：FileInputStream,BufferInputStream 读取一个字节 读取一个字节数组
  字节输出流：共同父类 OutputStream 比如：FileOutputStream,BufferOutputStream 写一个字节 写一个字节数组
  2.OutputStream:字节输出流的根类，这是一个抽象类
  public void close();
  public void flush(); //刷新流
  public void write(int b); //写一个字节
  public void write(byte[] bs); //写一个字节数组
  public void writre(byte[] bs,int startIndex, int lenght);//写一个字节数组的一部分
  3.续写和换行
  FileOutputStream fos = new FileOutputStream(“2.txt”,true);
  fos.write(“\r\nhello”.getBytes());
  fos.close();
  4.InputStream:字节输入流的根类，这是一个抽象类
  1.public int read();、、读取一个字节，返回是码值
  2.public int read(byte[] bs);//读取一个字节数组，返回值表示实际读取到的字节数
  我们用InputStream具体子类：FileInputStream
  一次读取一个字节
  FileIntputStream fis = new FileIntputStream(new File(“1.txt”));
  int b = 0;
  while(b=fis.read()!=-1)
  {

    System.out.println((char)b);

  }
  fis.close();
  一次读取一个字节数组
  byte[] bs = new byte[4];
  int len = fis.read(bs);
  System.out.println(len); //实际字节数
  System.out.println(new String(bs));
  标准：
  while((len = fis.read(bs)!=-1))
  {

    System.out.println(new String(bs,0,len))

  }
  复制文件：
  long s= System.currentTimeMillis(); //系统时间
  while((len = fis.read(bs)!=-1))
  {

    fos.writ(bs,0,len);

  }
  字节缓冲流：
  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputaStream(“1.txt”));
  字节流读取中文的乱码问题：读取中文读了一半
  解决问题：字符流 转化流
  字符编码表(字符集)
  ASCII码表
  在GBK码表中一个中文2个字节 在UTF-8中一个中文 3个字节
  OutputStreamWriter 是字符流通向字节流的桥梁，查码表(编码)
  OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“1.txt”));
  osw.close();
  字节->解码->字符： InputStreamReader
  字符->编码->字节： OutputStreamWriter
  transient关键字：
  用来修饰成员变量 用不用没有影响
  序列化的时候有用，如果一个成员变量被transient修饰，那么序列化的时候会忽略该成员变量
  static:关键字 他也具有和transient一样的功能
  打印流：
  PrintWriter:打印字符流
  PrintyStream:打印字节流

  使用第三方框架的步骤
  1.导入classpath
  a.在工程根目录下 建立一个目录”lib”
  b.把要使用的第三方框架的jar包拷贝过来
  c.添加构建路径 右键单击jar包—->Build Path —-> Add to Build Path
  以FileUtils为例

• 多线程

  1. 内存RAM 硬盘ROM
     多线程程序并不能提高程序的运行速度，但能够提高程序运行速率，让cpu的使用率更高。
     main方法所在线程 我们就称为主线程
     Thread类：线程类
     public Thread();//创建一个默认名字的线程对象
     public Thread(String name);//创建一个指定名字的线程对象
     第一种：继承
     class 子线程类 extends Thread{
     run(){

      任务代码

     }
     }
     子线程类 t = new 子线程类();
     t.start();
     第二种：声明实现Runable接口的类，重写run方法，创建实现类对象，创建Thread对象，并把刚刚的实现类对象 作为参数传递，启动这个Thread对象
     从耦合性分析用第二种
     扩展性:第一种继承Thread，那么子线程类就不能继承别的类
     第二种方式 由于是实现了接口，同时可以继承别的类
     匿名内部类创建线程对象
  2. new Thread(){
     public void run(){

      /////////

     }
     }.start();
  3. new Thread(new Runnable(){
     public void run(){

      /////

     }
     }).start();
     线程安全问题：1.同步锁 synchronized(obj)
  4. 同步方法:
     public synchronized void sale()
     {
     }
     这里同步方法使用的锁对象 叫做this对象
     这里同步方法是静态方法，那么他的锁对象是当前类.class
  5. lock接口方式
     实现类：ReentrantLock

• 网络编程 udp tcp
  InetAddress

• XML语法
  文档说明：

  作用：存放数据 配置文件
  CDATA区

#author:Ericam_

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

import re
import sys
from bs4 import BeautifulSoup
import urllib.request
import time
headers = ('User-Agent', 'Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1')
opener = urllib.request.build_opener()
opener.addheaders = {headers}
urllib.request.install_opener(opener)
def get_download(url):
    file = urllib.request.urlopen(url)
    data = BeautifulSoup(file , from_encoding="utf8")    
    section_name = data.title.string
    print(section_name)
    section_text = data.select('#content #left font')[0].text
    section_text=re.sub( '\s+', '\r\n\t', section_text).strip('\r\n')
    fp = open("D:/python/2.txt",'a',encoding='utf-8')   
    fp.write(section_name+'\n')  
    fp.write(section_text+'\n')  
    fp.close()

if __name__ == '__main__':
    url = "http://www.net767.com/shuji/fubaba/10995.html"
    while(True):
        file = urllib.request.urlopen(url)
        data = BeautifulSoup(file , from_encoding="utf8")    
        section_name = data.title.string
        print(section_name)
        section_text = data.select('#content #left font')[0].text
        section_text=re.sub( '\s+', '\r\n\t', section_text).strip('\r\n')
        print(section_text)
        txt_section=data.select('#pagebar a')
        l1=len(txt_section)
        for num in range(1,l1-1):
            y=txt_section[num]['href']
            url = "http://www.net767.com"+y
            get_download(url)
            print(y)
        txt2_section=data.select('.LinkNextArticle')
        y2=txt2_section[0]['href']
        url = "http://www.net767.com"+y2
        if(url == 'http://www.net767.com/shuji/fubaba/11003_9.html'):
            break
        print(y2)

• 集合(collection)：
  数组的长度是固定的，集合的长度是可变的。
  每一个容器的数据结构不一样
  Collection接口定义着集合框架中最最共性的内容
  size(); add(); remove(); clear(); contains(); toArray();
  集合的遍历：
  在根接口中使用了一种公共的遍历方式，迭代器遍历

  1. 获取一个集合的迭代器对象(迭代器对象不是我们创建的，而是每个集合自带的) 是一个接口

     1 2 3 4 5

     Iterator<String> it = names.iterator(); while(it.hasnext()){ String s = it.next(); System.out.println(s); }

     java规定，如果一个集合使用迭代器遍历，那么遍历的过程中，不允许修改集合长度
  2. 增强for循环
     Collection names = new ArrayList();
     for(数据类型 变量名：数组/集合){
     syso(变量名);
     }
     使用增强for循环遍历集合的时候，不能修改集合的长度
  3. 泛型:E实际上是一个“变量” 用来保存一种数据类型
     ,<K,V>
     可以用在类，方法，接口上。
     泛型通配符
     ？：代表任意类型
  4. Collections.shuffle(cards); //洗牌
  5. 栈，队列
     数组结构 Arraylist Vector 查询快，增删慢
     链表结构：一般使用双向链表
     哈希表结构：查询快 增删快
  6. List接口特点：有下标，有序的，可重复
     实现类：ArrayList,LinkedList,Vector 安全
     List结构中的方法：
     增：add(E e); add(int index,E e)
     删：remove(Object obj);remove(int index);
     改：set(int index,E e);
     查：get(int index);
     其他：
     size();clear(),contains(Object obj),toArray();
     iterator();isEmpty();
  7. ArrayList:方法基本和List一致
  8. LinkedList:还有大量的首尾操作方法
     void addFirst(E e);
     E removeFirst();
     E getFirst();
     E pop(); 和removeFirst一致
     void push(E e); 推入 和addFirst一致
  9. Set接口
     a.无下标
     b.无序的
     c.不可重复
     实现类：
     HashSet：底层采用哈希表结构，查询快，增删快，无序的
     LinkedHashSet:链表＋哈希表，查询快，增删快，有序
     Set接口中的特有方法和Collection基本一致
     TreeSet:红黑树
  10. 哈希表
      哈希值：每一个对象都具有哈希值
      地址值实际是哈希值的16进制
      String对象的哈希值：重写了Object类中的hashCode
      不再通过地址值计算 只和字符串内容相关
      哈希表结构，添加元素判断是否重复
  11. 先判断新旧元素的哈希值
  12. 再判断新旧元素的equals
      自定义类，要使用HashSet存储
      保证元素唯一性：
      必须重写自定义类的两个方法 hashcode equals
      定义一个标准得类：
  13. 封装
  14. 构造
  15. toString
  16. hashCode equals
      contains方法：
      ArrayList:names.contains(“abc”);
      HashSet:set.contains(“abc”);
  17. Map接口
      Map<K,V>集合常用方法： 、
      HashMap
      增：put(K key,V value); //向集合中添加键值对
      //如果集合中已存在该键，覆盖整个键值对，并返回被覆盖的键值对的值
      判断k是不是空
      哈希表结构，添加元素判断是否重复
  18. 先判断新旧元素的哈希值
  19. 再判断新旧元素的equals
      删：v remove(object key); //返回被删除的键值对的值
      改：==put
      查：V get(K key); 判断是不是空
      Map集合遍历： LinkedHashMap HashMap
      getKey();
      getValue();
  20. keySet遍历
      Set keys = students.keySet(); //放在set集合中
      map.KeySet(); Iterator hasnext
      for(String key : keys)
      {
      String value = students.get(key);
      }
  21. Set<Map.Entry> entrySet = map.entrySet();
      Iterator<Map.Entry<String,String>> it = entrySet.iterator();
      while(it.hasNext(){
      Map.Entry<String, String> entry = it.next();
      String key = entry.getKey();
      String value = entry.getValue();
      system.out.println(key+”=”+value)；
      })

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

      import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class MapTest { public static void main(String[] args) { Map<Integer, String> map = new HashMap<>(); //map集合存入数据 map.put(1, "第一个value"); map.put(2, "第二个value"); map.put(3, "第三个value"); //通过keySet取出map数据[for-each循环] System.out.println("-------[for-each循环遍历]通过keySet取出map数据-------"); Set<Integer> keys = map.keySet(); //此行可省略，直接将map.keySet()写在for-each循环的条件中 for(Integer key:keys){ System.out.println("key值："+key+" value值："+map.get(key)); } //通过EntrySet取出map数据[for-each循环] System.out.println("-------[for-each循环遍历]通过EntrySet取出map数据-------"); Set<Entry<Integer, String>> entrys = map.entrySet(); //此行可省略，直接将map.entrySet()写在for-each循环的条件中 for(Entry<Integer, String> entry:entrys){ System.out.println("key值："+entry.getKey()+" value值："+entry.getValue()); } //通过keySet取出map数据[Iterator遍历] System.out.println("-------[Iterator循环遍历]通过keySet取出map数据---------"); Iterator<Integer> it = map.keySet().iterator(); //map.keySet()得到的是set集合，可以使用迭代器遍历 while(it.hasNext()){ Integer key = it.next(); System.out.println("key值："+key+" value值："+map.get(key)); } //通过EntrySet取出map数据[Iterator遍历] System.out.println("-------[Iterator循环遍历]通过EntrySet取出map数据---------"); Iterator<Entry<Integer, String>> iterator = map.entrySet().iterator(); //map.entrySet()得到的是set集合，可以使用迭代器遍历 while(iterator.hasNext()){ Entry<Integer, String> entry = iterator.next(); System.out.println("key值："+entry.getKey()+" value值："+entry.getValue()); } } }

      内部类：
      OutClass.InterClass ic = new OutClass.new InterClass();
      内部接口 实现谁，重写谁
      如果Map中的键是自定义类型，那么要保证键的唯一性，必须重写键对应类的hashCode和equals方法
  22. Properties类
      本质就是一个Map集合
      持久的属性集
      ps.store(new FileWriter(“phones.properties”),””);//存
      ps.load(new FileReader(“phones.properties)); //读取
      没有泛型
      具有Map接口的一切方法，以及自己特有的
      getProperty();
      setProperty();
      public Set stringPropertyNames();//和KeySet一样
      Properties ps = new Properties();
      可变参数：
      public static int add(int…a){
      return 0;
      }
      //类型不能改变，多个参数时，可变参数在最后面
      本质：数组 for(int i : a)
      Collections：(集合工具类)中的静态方法：
      public static void shuffle(List list);//打乱顺序
      public static void sort(List list);//把集合元素按照自然顺序排序
      Arrays:数组工具类
      public static List asList(数组/可变参数); //把数组转化为List集合
      Arrays.sort(nums);
      Arrays.toString(nums);
      Map集合的嵌套：

• File类

  1. File类可以表示文件 也可以表示文件夹
     构造：
     1.public File(String filepath);
     绝对路径：以盘符开头的路径
     相对路径：相对当前项目的根目录
     2.public File(String parent ,String child);
     3.public File(File parent,String child);
  2. File对象的获取方法
     public String getAbsolutePath();//获取绝对路径
     getName(); getPath();
     public long length(); //获取File对象(文件)的字节数 不能计算文件夹
  3. File对象的删除和创建方法：
  4. 创建方法
     创建文件：

       public boolean creatNewFile(); //创建新的文件

     创建文件夹

       public boolean mkdir();

  5. 判断方法
     判断是否是文件

       public boolean isFile();

     判断是否是文件夹

       public boolean isDirectory();

     判断是否存在

       public boolean exists();

  6. 删除

       public boolean delete();

  7. File类下的list和listFiles方法(文件夹)
     1.public String[] list();
     2.public File[] listFiles();
     只能列出当前文件下的一级子文件或者子文件夹
     扩展：删除先删文件再删文件夹
  8. 递归打印目录下的所有文件
  9. 文件过滤器：FileFilter
     在list和listFiles方法中使用

javascript

用法：

HTML 中的脚本必须位于 标签之间。脚本可被放置在 HTML 页面的 和 部分中，也可以保存在外部文件中（则不需要加标签）。

输出：

• 使用 window.alert() 弹出警告框。
• 使用 document.write() 方法将内容写到 HTML 文档中。
• 使用 innerHTML 写入到 HTML 元素。
• 使用 console.log() 写入到浏览器的控制台。