Forth Week ：快速上手一门编程语言

概述

图灵完备性语言

图灵完备的语言，有循环执行语句，判断分支语句等。理论上能解决任何算法。但有可能进入死循环而程序崩溃。
Pyhton java php等都是图灵完备的

识别类型

https://blog.csdn.net/sinat_38682860/article/details/86492429?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromBaidu-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromBaidu-1.control
四个概念：
强类型 & 弱类型
动态类型 & 静态类型
因此：
Python是动态强类型语言 编程语言环境帮助我们判断类型
Java是静态强类型的
C是静态弱类型的 char a -> %c显示a %d显示65 人来判断是什么类型 （PHP也是弱类型）
强弱是指本身能够判断这个变量是什么类型
动静是指声明变量时指定变量类型是静态类型(有强制类型转换)，不需要指定的是动态类型(可以自动转换)。

学习路径

一 掌握该语言的背景 - 2h

二 掌握该语言的基本程序逻辑语法 - 1h

1、顺序结构

2、分支结构

1）if语句

if(表达式){
	语句块；
}
else if(表达式){
	语句块；
}
else{
	语句块；
}
 

2）switch … case多分支语句

switch(表达式){
	case 常量1：{
		语句块；
		break；
	}
	case 常量2：{
		语句块；
		break；
	}
	[default:
		{语句块；}
	]
}

3、循环结构

break和continue语句：break是终止本层循环，跳到外层继续执行代码；continue终止本次循环，继续下一次循环；

1）while

public static void main(String args[]){
	int result = 0;
	int i = 0;
	while(i<=100){
		result += i;
		i++;
	}
	System.out.println("result = "+result);
}

2）do…while

public static void main(String args[]){
	int result = 0;
	int i=0;
	do{
		result += i;
		i++;
	}while(i<=100);
	System.out.println("result = "+result);
}

3）for

public static void main(String args[]){
	for (int i=0;i<10;i++){
		if(i==3) break;
		System.out.println("i = "+i);
	}
	System.out.println("Game over!");
}

4）foreach 【java5的新特征之一】

for(元素类型t 元素变量x：遍历对象obj){ 
 	引用了x的java语句；
}

public void test(){
	int arr[] = {2,3,4};
	System.out.println("-----排序前一维数组-----");
	for(int x:arr){
		System.out.println(x);//逐个输出数组元素
	}
	Arrays.sort(arr);
	System.out.println("-----排序后一维数组-----");
	for(int x:arr){
	 	System.out.println(x);
	}
	
	//输出二维数组
	int arr2[][] = {{1,2,3},{4,5,6}};
	System.out.println("二维数组输出测试");
	for(int x[] : arr2){
		for(int e:x){
			System.out.println(e);
		}
	}
	
	//输出三维数组
	int arr3[][][] = {{{1,2},{3,4}},{{5,6},{7,8}}};
	System.out.println("三维数组输出测试");
	for(int[][] a2:arr){
		for(int[] a1:a2){
			for(int x:a1){
				System.out.println(x);
			}
		}
	}
}

三 掌握该语言的变量 - 2h

1 明确语言的类型

静态？动态？
强 or 弱 ？

2 基本类型和封装类型

变量类型是值 or 引用类型？
C、C++ - 值类型（保存地址） Python、Javascrip - 引用类型（保存指针 判断时用equal判断，否则判断指针指的是否是同一个地址了） Java 两者都有

1）基本数据类型

（1）内置数据类型

八种基本类型：六种数字类型（四种整数型、两个浮点型），一种字符类型，一种布尔类型。

byte：8位，有符号
short：16位，有符号
int：32位，有符号
long：64位，有符号
float：单精度、32位
double：双精度、64位
boolean：表示一位的信息，取值true和false
char：单个的16位Unicode字符

（2）引用数据类型

类似于C/C++的指针，引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型(Employee,Puppy)，变量一旦声明后，类型就不能改变了。

• 对象、数组都是引用数据类型。
• array.clone() 否则传过去的是地址
• 所有引用类型的默认值都是null。
• 一个引用类型可以用来引用任何与之兼容的类型。

Site site = new Site("Jacob")

（3）常量

常量在程序运行时不能被修改，使用final关键字来修饰，声明方式和变量类似，变量名常使用大写字母：

final double PI = 3.14159;

（4）特殊转义字符

（5）类型转换

运算符

1）算数运算符

符号	含义
＋	加
–	–
-	减
–	–
*	乘
–	–
/	除
–	–
%	求余
–	–
++	自增
–	–
–	自减

2）关系运算符

符号	含义
==	判断是否相等
–	–
!=	判断是否不等
–	–
>	大于？
–	–
<	小于？
–	–
>=	大于等于？
–	–
<=	小于等于？

3）位运算符

符号	含义
&	与
–	–
–	–
^
–	–
~	按位取反
–	–
<<	按位左移
–	–
>>	按位右移

4）逻辑运算符

符号	含义
&&	逻辑与
–	–
–	–
！	逻辑非

5）赋值运算符

6）其他运算符

泛型

*
 * 自定义泛型
 * 泛型字母：T Type
 * 			K V key value
 * 			E Element
 * 泛型类：只能用在成员变量上，只能使用引用类型
 * 泛型接口：只能用在抽象方法上
 * 泛型方法：返回值前加上
 * */
 * //利用泛型方法打印不同的字符串元素
public class GenericMethodTest {
	public static <E> void printArray(E[] inputArray) {
		for(E x:inputArray) {
			System.out.printf("%s ",x);
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		Integer[] intArray = {1,2,3,4,5};
		Double[] doubleArray = {1.1,1.2,1.3,1.4};
		Character[] charArray = {'a','b','c','d'};
		
		System.out.println("整型数组元素为：");
		printArray(intArray);
		System.out.println("浮点型数组元素为：");
		printArray(doubleArray);
		System.out.println("字符串型数组元素为：");
		printArray(charArray);
		
	}
}

 //  <任意字符extends类/接口> 表示泛型的上限, 同样的super表示泛型的下限
public static  <T extends Comparable<T>> T maximum(T x,T y,T z) {
		T max = x;
		if(y.compareTo(max)>0) {
			max = y;
		}
		if(z.compareTo(max)>0) {
			max = z;
		}
		return max;
	}
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);		
		
		System.out.println("请输入三个整型数字：");
		int a = scan.nextInt();
		int b = scan.nextInt();
		int c = scan.nextInt();
		System.out.println("最大的数为："+maximum(a,b,c));
		
		System.out.println("请输入三个浮点型数字：");
		float d = scan.nextFloat();
		float e = scan.nextFloat();
		float f = scan.nextFloat();
		System.out.println("最大的数为："+maximum(d,e,f));
		
	}

3 时间和日期的类型和处理

保存时间1970年格林威治到现在的时间戳
Date类

public static void main(String[] args) {
  Date date = new Date(); //初始化Date对象
  System.out.println(date.toString());
  
  /*日期比较
  1. getTime()方法获取两个时间，然后比较
  2. before() after() equals()方法
     eg:new Date(99,2,12).before(new Date(99,2,18)) 返回true
  3. 使用compareTo()方法
  */
  /*
   * 解析字符串为时间
   * SimpleDateFormat类
   * */
  SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
  
  String input = args.length == 0? "1818-11-11 " : args[0];
  System.out.print(input + "Parse as ");
  Date t;
  try {
   t = ft.parse(input);
   System.out.println(t);
  }catch(ParseException e) {
   System.out.println("Unparseable using"+ft);
  }
  
  /*
   * Sleep休眠 阻塞当前进程
   * */
  
  try {
   System.out.println(new Date() +"\n");
   Thread.sleep(3*1000);
   System.out.println(new Date() + "\n");
  }catch (Exception e) {
   System.out.println("GOT an exception!");
  }
 
 }

Calendar类

4 字符串的实现和种类

可变 or 不可变？
字符串常量池 ：String创建的字符串存储在公共池中，而new创建的字符串对象在堆上

//初始化方式
String s1 = "runoob";  //String直接创建
String s2 = "runoob";
String s3 = s2;//相同引用

String s4 = new String("runoob");//对象创建
String s5 = new String("runoob");

//也可以提供字符数组
char[] helloArray = new char[] {'h','e','l','l','o'};
String helloSrting = new String(helloArray);

//字符串也可以直接转换成字符数组
char[] arr = helloString.toCharArray();

//内置字符串函数
1.连接concat()或者+
2.equals() compareTo(Object o) 
equalsIgnoreCase()//忽略大小写
compareTo(String otherstring)
contentEquals(StringBuffer sb)  //与stringbuffer有相同顺序的字符时，返回真 
length()
replace(oldChar, newChar) replaceAll() replaceFirst()
split() trim()
startsWith() endsWith()
toUpperCase() toLowerCase()
indexOf() contains() subString()
isEmpty()

StringBuffer类、StringBuilder比StringBuffer速度快
使用stringBuffer类时，每次都会对Stringuffer对象本身进行操作，而不是生成新的对象，要求线程安全的情况下，必须使用StringBuffer类

StringBuffer sBuffer = new StringBuffer("cainiaoguanwang:");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer);

StringBuilder sb = new StringBuilder(10);
sb.append("Runoob....");
System.out.println(sb);
sb.append("!");
sb.insert(8,"java");
sb.delete(5,8);
System.out.println(sb);

正则表达式函数 Matcher类
特殊点：
在 Java 中，\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。正常反斜杠表示：\\

String line = "This line is a test!";
String pattern = "(\\D*)(\\d+)(.*)";

Pattern r = Pattern.compile(pattern);
Match m = r.matcher(line);
if(m.find()){
	System.out.println(m.group(0));
	System.out.println(m.group(1));
   	System.out.println(m.group(2));
  }else {
  	 System.out.println("No match!");
  }
/*
   * ^ 开始位置
   * $ 结束位置
   * * 零次或多次匹配
   * + 一次或多次匹配
   * ? 零次或一次匹配
   * {n} 正好匹配n次
   * {n,} 至少匹配n次
   * {n,m} 至少n次，至多m次
   * (pattern) 匹配pattern并捕获该匹配的子表达式
   * x|y  匹配x或者y
   * [xyz] 字符集，匹配集合中的任意一个字符
   * [a-z] 字符范围
   * \d 数字字符 \D非数字字符
   * */

四 容器对象学习 - 1h

Hash map、字典、数组等等
Java -
C++ 导入模板库
1、容器对象的种类和实现原理
2、遍历
3、深浅复制
4、序列化和反序列化
5、查阅手册，了解全部容器支持的函数并掌握常用容器操作函数

public static void main(String args[]) {
  //枚举  一次获得一个元素  很少使用
  Enumeration<String> days;
  Vector<String> dayNames = new Vector<String>();
  dayNames.add("Sunday");
  dayNames.add("Monday");
  dayNames.add("Tuesday");
  dayNames.add("Wednesday");
  days = dayNames.elements();
  while (days.hasMoreElements()) {
   System.out.println(days.nextElement());
  }
  
  //位集合测试
  BitSet bits1 = new BitSet(16);
  BitSet bits2 = new BitSet(16);
  
  for(int i=0;i<16;i++) {
   if((i%2) == 0) bits1.set(i);
   if((i%5) != 0) bits2.set(i);
  }
  System.out.println("bits1: "+bits1);
  System.out.println("bits2: "+bits2);
  
  //Vector类  动态数组和arraylist类似，但两者不同
  //1.四种构造方法
  Vector v = new Vector(3,2);
  System.out.println("Initial Size："+v.size());
  v.addElement(new Integer(1));
  v.addElement(new Integer(2));
  v.addElement(new Integer(3));
  System.out.println(v);
  System.out.println("Initial capacity："+v.capacity());
  
  //栈stack 本质是vector 除此之外自己也定义了一些方法
  Stack st = new Stack();
  st.push(new Integer(1));
  st.push(new Integer(2));
  st.push(new Integer(3));
  st.push(new Integer(4));
  Integer x = (Integer) st.pop();
  System.out.println(x);
  x = (Integer) st.pop();
  System.out.println(x);
  x = (Integer) st.pop();
  System.out.println(x);
  x = (Integer) st.pop();
  System.out.println(x);
  
  //MAP接口 提供了键映射到值，可以通过键来获取值
  Map m1 = new HashMap();
  m1.put("zhang",18);
  m1.put("gao", 22);
  m1.put("li",23);
  m1.put("han",31);
  System.out.println(m1.size());
  System.out.println(m1.get("gao"));
  System.out.println(m1.hashCode());
  System.out.println(m1.remove("gao"));
  System.out.println(m1.values());
//  for(int i=0;i<m1.size();i++) {
//   System.out.println(m1.get(i));
//  }
  
  //迭代器  通常情况下使用迭代器遍历一个集合的元素
  //可以使用Iterator接口或者ListIterator接口
  List<String> list = new ArrayList<String>();
  //1.使用foreach遍历list
  list.add("hello");
  list.add("world");
  list.add("hahahah");
  
  for(String str:list) {
   System.out.println(str);
  }
  
  //2.把链表变为数组相关的内容进行遍历
  String[] strArray = new String[list.size()];
  list.toArray(strArray);
  for(int i=0;i<strArray.length;i++) {
   System.out.println(strArray[i]);
  }
  
  //3.使用迭代器进行相关遍历
  Iterator<String> ite = list.iterator();
  while(ite.hasNext())//判断下一个元素之后有值
  {
   System.out.println(ite.next());
  }
 }

深浅复制
序列化和反序列化
transient关键字修饰的变量不能够被序列化

//首先实现一个employee类
public class Employee implements java.io.Serializable{
	public String name;
	public String address;
	public transient int SSN;
	//transient关键字 某个字段不被序列化
	public int number;
	public void mailCheck() {
		System.out.println("Mailing a check to "+name+" "+address);
	}
}
//实现序列化
public class SerializeDemo {
	public static void main(String[] args) {
		Employee e = new Employee();
		e.name = "a";
		e.address = "absn";
		e.SSN = 123454;
		e.number = 101;
		File file = new File("./employ.ser");
		try {
			if(!file.exists()) {
				file.createNewFile();
			}
			FileOutputStream fout = new FileOutputStream(file);
			ObjectOutputStream o = new ObjectOutputStream(fout);
			o.writeObject(e);
			o.close();
			fout.close();
		}catch(IOException i) {
			i.printStackTrace();
		}
	}
}

//反序列化
public class SerializeDemo2 {
	public static void main(String[] args) {
		Employee e = new Employee();
		String fileName = "./employ.ser";
		File file = new File(fileName);
		try {
			FileInputStream fin = new FileInputStream(file);
			ObjectInputStream o = new ObjectInputStream(fin);
			e = (Employee) o.readObject();
			System.out.println(e.name);
			System.out.println(e.address);
			System.out.println(e.SSN);  // 未被序列化未保存，反序列化结果0
			System.out.println(e.number);
			o.close();
			fin.close();
		}catch(IOException | ClassNotFoundException i) {
			i.printStackTrace();
		}
	}
}

五 实现抽象的方法、类、接口与函数的实现、使用 - 2h - coder

1、函数的定义与调用
2、参数使用与传递方式
3、类和对象的实现方式 - 封装继承多态
4、多继承还是接口
5、常见的设计模式的实现，单例模式、代理模式（委托），观察者模式

六 函数式编程的支持

1、高阶函数对象
2、语法特性与编程习惯（如链式语法、闭包等）

七 依赖与项目管理工具与生态支持 - developer

java的maven、gradle

八 内置高级功能 - professional

并发模型、多线程，多进程，系统调用，磁盘管理，数据库管理，网络支持等特性
至少要会查看手册

任务：
1、完成一个支持消息循环的交互程序
开始运行之后不结束 while循环之类的 通过输入某个命令，再退出
rpg小程序 完成六步以上的剧情？？
精细的控制 二进制位进行操作
交互应用程序 凯撒密码对数据进行加密
加密前选择位移的序号 在输入一串字符串 回车后输出加密字符串 放到文本 在解密程序 导入标准输入流 输入一个序号
破解 不知道加密序号 导入文本中数据 找到加密序号 找出加密前的 正确的字符串需要人为判断 机器只是工具 人才知道要的是什么

public class HomeWork1 {
	
	public static void jiami() {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入待编码的数据(英文):");
		String data1 = scan.nextLine();
		System.out.println("请输入位移位数:");
		int number = scan.nextInt();
		int i=0;
		char[] data_arr = data1.toCharArray();
		for(i=0;i<data_arr.length;i++) {
			
			if(data_arr[i]>='a' && data_arr[i]<='z') {
				data_arr[i]+=number;
				if(data_arr[i]>='z') {
					data_arr[i] -= 26;
				}
					
			}else if(data_arr[i]>='A' && data_arr[i]<='Z') {
				data_arr[i] += number;
				if(data_arr[i]>='Z') {
					data_arr[i] -= 26;
				}
			}
		}
		System.out.println();
		System.out.println("加密结果:");
		System.out.println(data_arr);
	}
	
	public static void jiemi() {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入待解密的数据(英文):");
		String data1 = scan.nextLine();
		System.out.println("请输入秘钥:");
		int number = scan.nextInt();
		int i=0;
		char[] data_arr = data1.toCharArray();
		for(i=0;i<data_arr.length;i++) {
			
			if(data_arr[i]>='a' && data_arr[i]<='z') {
				data_arr[i]-=number;
				if(data_arr[i]<'a') {
					data_arr[i] += 26;
				}
					
			}else if(data_arr[i]>='A'&&data_arr[i]<='Z') {
				data_arr[i] -= number;
				if(data_arr[i]<'A') {
					data_arr[i] += 26;
				}
			}
		}
		System.out.println();
		System.out.println("解密结果:");
		System.out.println(data_arr);
	}
	public static char[] jie(char[] data_arr,int key) {
		int i=0;
		for(i=0;i<data_arr.length;i++) {
					if(data_arr[i]>='a' && data_arr[i]<='z') {
						data_arr[i]-=key;
						if(data_arr[i]<'a') {
							data_arr[i] += 26;
						}
							
					}else if(data_arr[i]>='A'&&data_arr[i]<='Z') {
						data_arr[i] -= key;
						if(data_arr[i]<'A') {
							data_arr[i] += 26;
						}
					}
		}
		return data_arr;
	}
	
	public static void pojie() {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入待破解的数据(英文):");
		String data1 = scan.nextLine();
		char[] data2 = data1.toCharArray();
		
		for(int i=0;i<26;i++) {
			char[] temp = data2;
			temp = jie(temp,i);
			System.out.println("key #:"+i);
			System.out.println(temp);
			}
		}
	
	public static void main(String[] args) {
		while(true) {
			System.out.println("*****凯撒密码******");
			
			Scanner scan = new Scanner(System.in);
			System.out.println("请输入想要进行的功能:");
			
			System.out.println("***1.加密功能***");
			System.out.println("***2.解密功能***");
			System.out.println("***3.破解功能***");
			
			System.out.println("***0.退出***");
			int choose1 = scan.nextInt();
			switch(choose1) {
			case 0:
				return;
				
			case 1:
				jiami();
				break;
				
			case 2:
				jiemi();
				break;
				
			case 3:
				pojie();
				break;
		
			
			default:
				break;
			}
		}
		
	}
}

九 文件读取和写入

1、文件类继承关系

2、文件读取
（2）按行读取
使用BufferedReader中的readLine()方法。无参数，返回包含改行的内容字符串，不包含任何行终止符，如果已经到达流末尾，则返回null。

int position=0;
String[] bufstring = new String[1024];
//打开带读取的文件
BufferedReader br = new BufferedReader(new FileReader("text.txt"));
String line = null;
while((line=br.readLine())!=null){
        bufstrig[position]=line;
        positon++;
}
br.close(); //关闭文件
for(int i;i<position;i++){
        System.out.println(bufstring[i]);
}

(3)自动换行写入
利用OutputStream中的Println()方法

int number = 1;
OutputStream os = new FileOutputStream("output.txt");
PrintWriter pw = new PrintWriter(os);
for(int i=0;i<10;i++){
        String s = ""+number;
        pw.println(s);//每输入一个数据，自动换行
        //pw.println(s+",");//不会自动换行，必要时可自己添加分隔符
        number++;
}
pw.close();
os.close();