计算机天才协会学习周报

本周学习大纲

1.Java：正则表达式，集合框架

2.学习office的使用

3.复习C语言

本周学习日历

完成状态

全部完成

本周学习总结

本周做了四天暑假工，用空余时间来学习，主要是JAVAse，学完这一块差不多就能开始学javaweb了。之前在C语言学习中有一些漏洞，所以给补上，还有就是office，这种工具类软件，感觉还是很重要的，打算慢慢地熟悉熟悉。

泛型方法

1.泛型方法的定义

1
2
3

public <类型参数> 返回类型 方法名（类型参数 变量名） {
    ...
}

1)只有在方法签名中声明了< T >的方法才是泛型方法，仅使用了泛型类定义的类型参数的方法并不是泛型方法。

public class Test<U> {
    // 该方法只是使用了泛型类定义的类型参数，不是泛型方法
    public void testMethod(U u){
        System.out.println(u);
    }
    // 真正的泛型方法
    public <T> T testMethod1(T t){
        return t;
    }
}

2）泛型方法中可以同时声明多个类型参数

1
2
3
4
5

public class TestMethod<U> {
	public <T, S> T testMethod(T t, S s) {
		return null;
	}
}

☆3）泛型类中定义的类型参数和泛型方法中定义的类型参数是相互独立的，它们一点关系都没有，泛型方法中也可以使用泛型类中定义的泛型参数。

2. 泛型方法的使用

• 泛型类，在创建类的对象的时候确定类型参数的具体类型；

• 泛型方法，在调用方法的时候再确定类型参数的具体类型。

泛型方法签名中声明的类型参数只能在该方法里使用，而泛型接口、泛型类中声明的类型参数则可以在整个接口、类中使用

当调用泛型方法时，根据外部传入的实际对象的数据类型，编译器就可以判断出类型参数 T所代表的具体数据类型。

泛型通配符

• 就是“？”，可以在使用泛型时代表一切类型；
• 类型通配符是类型实参，而不是类型形参

使用通配符的情形：

• 例如一个方法定义了< Number >类型，而调用时声明的< Integer >类型（虽然Integer继承Number，所以也没法重写）会报错，这时想支持多种类型，可以用通配符 < ? >；
• < ? > 定义的 用 Object 类型来接收

1
2
3

public static void show(A<?> B){
	 Object value = B.getValue();
}

通配符的上限

1

类/接口 <? extends 实参类型>

• 要求该泛型的类型，只能是实参类型，或实参类型的子类类型；

• 这里的实参类型就是泛型的类型的上限

如：

1
2
3
4

public static void show(Box<? extends Number> box){
	 Number value = box.getValue();//类型最大为Number
}

通配符的下限

1

类/接口 <? super 实参类型>

泛型的擦出问题和注意事项

泛型是工作在编译环境里的，一旦程序编译成class文件，class文件中就不存在泛型了，这就是泛型擦除

例如：

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

// 原代码(部分)
ArrayList<String> list =new ArrayList<>();
list.add("java1");
list.add("java2");
String rs = list.get(2);
System.out.println(rs);

// 泛型擦除后
ArrayList list =new ArrayList<>();
list.add("java1");
list.add("java2");
String rs = (String)list.get(2);
System.out.println(rs);

泛型不支持基本数据类型，只支持对象类型（引用数据类型）

如：

1
2
3
4
5

// 错误代码
ArrayList<int> list1=new ArrayList<>();

// 正确代码（Interger类就是在对象中包装了一个基本类型为int的值）
ArrayList<Interger> list1=new ArrayList<>();

好了，到这里，关于泛型的知识就大致地了解了，

再重复一遍泛型的概念：定义类、接口、方法时，同时声明了一个或多个类型变量，称为泛型类、泛型接口、泛型方法，统称为泛型

作用：提供了在编译阶段约束所能操作的数据类型，并自动检查的能力！可以避免强制类型转换。

计算机天才协会学习周报

本周学习大纲

1.Java：常用API，算法

3.复习高数，离散

本周学习日历

完成状态

全部完成

本周学习总结

这周有点懈怠了，好焦虑，主要还是java和学校课程的复习，这周“常用API”学习了有一半了，准备下周看完常用API，加上一部分集合框架，努努力下下周差不多就学够了，不过javaweb是没怎么动。

计算机天才协会学习周报

本周学习大纲

1.Java：内部类，枚举，泛型

3.复习大物，离散

本周学习日历

完成状态

全部完成

本周学习总结

本周还算充实，JAVA和课程都照顾到了，之前落下了一些课补得也不算慢，但是很粗糙，包括JAVA的学习，视频里每一部分都跟着弄就太慢了（哭了），只能把基础的学了，补充内容选择性地看吧。

与static的第一次相遇

刚开始接触JAVA语言，在属于我的第一个类中写下的第一个方法——main方法：

1
2

public static void main(String[] args){
}

B站的老师告诉我“至于这几个词到底是什么意思，暂时不需要了解哈”，确实是暂时的，不久后，在“面向对象高级一”的课程中，我首先就要认识static的含义（悲）

了解static

static，我们可以在轻易地搜索到它的含义：

作形容词：静止的，停滞的

作名词：静电

在JAVA语言里，我们理解为：静态

static的作用范围

java中的static关键字主要用于内存管理，属于类，而不是类的实例

static(静态)可以用来修饰：

1. 变量：称为类变量或静态变量
2. 方法：称为类方法或静态方法
3. 代码块：称为静态代码块
4. 嵌套类：称为静态内部类

静态变量

成员变量按有无static修饰，分为两种：

1. 类变量（静态成员变量）：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享
2. 实例变量（对象的变量）：无static修饰，属于每个对象的。

静态变量

1. 运行时，Java 虚拟机只为静态变量分配一次内存，加载类过程中完成静态变量的内存分配。
2. 在类的内部，可以在任何方法内直接访问静态变量。
3. 在其他类中，可以通过类名访问该类中的静态变量。

实例变量

1. 每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
2. 在类的内部，可以在非静态方法中直接访问实例变量。
3. 在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

静态方法

同成员变量，成员方法也可以分为以下两种：

1. 静态方法（或称为类方法），指被 static 修饰的成员方法。
2. 实例方法，指没有被 static 修饰的成员方法

类方法（静态方法）：有static修饰的成员方法，属于类

1
2
3

public static void aaa(){
    ...
}

可以用直接用类名访问，也可以用对象访问

1
2

类名.类方法（推荐）
对象名.类方法

1. 它通过类直接被调用，无需创建类的对象。
2. 静态方法中，不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法；
3. 静态方法中，可以直接访问所属类的静态变量和静态方法。
4. 同this 关键字，super 关键字也与类的实例相关，静态方法中不能使用 super 关键字。

实例方法（对象的方法)：无static修饰的成员方法，属于对象

只能用对象访问

1

对象名.实例方法

实例方法，可直接访问所属类的静态变量、静态方法、实例变量和实例方法。

静态方法与静态变量适用场景：

1. 静态方法，最适合工具类中方法的定义；比如文件操作，日期处理方法等。
2. 静态方法，适合入口方法定义；比如单例模式，因从外部拿不到构造函数，所以定义一个静态的方法获取对象非常有必要。
3. 静态变量适合全局变量的定义；举例：用一个布尔型静态成员变量做控制标志。

静态代码块

静态代码块

格式：static{}

有static修饰的成员方法，属于类

1. 静态代码块，有点类似于一个方法，但不可以存在于任何方法体内。
2. 静态代码块，可以置于类中的任何地方，类中可以有多个静态初始化块。
3. Java 虚拟机在加载类时执行，将只需要进行一次初始化的操作放在 static 代码块。
4. 类中含多个静态代码块，Java虚拟机将按它们在类中出现的顺序依次执行，且都执行一次。
5. 同静态代码块与静态，不能直接访问类的实例变量和实例方法，需通过类的对象访问。

实例代码块

无static修饰的成员方法，属于对象

格式：{}

特点：每次创建对象时，执行示例代码块，并在构造器前完成。

作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

静态类

java中一个类要被声明为static的，只有一种情况，就是静态内部类（内嵌类）。如在外部类声明为static的，程序会编译都不会通过。

1、静态内部类，跟静态方法一样，只能访问静态成员变量和方法，不能访问非静态方法和属性。

2、普通内部类，可以访问任意外部类的成员变量和方法。

3、静态内部类，可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法。

4、静态内部类，可以单独初始化。

1

Inner i = new Outer.Inner();

普通内部类初始化：

1
2

Outer o = new Outer();
Inner i = o.new Inner();

适用场景：当外部类需要使用内部类，而内部类无需外部类资源，并且内部类可以单独创建时，考虑采用静态内部类的设计，在知道如何初始化静态内部类。

计算机天才协会学习周报

本周学习大纲

1.Java：复习（打代码实现案例），学习Javaweb

2.程序建模比赛论文

3.复习大物、线代

本周学习日历

完成状态

全部完成

本周学习总结

本周在专业课外的课程学习上，明显进步，然而，突然发现之前java学习进度完全不够，差了好多，遂放弃学习javaweb，不过本身课程就有html和css，也算有一点进度（？）。

计算机天才协会学习周报

本周学习大纲

1.Java：复习（打代码实现案例），学习Javaweb

2.程序建模比赛论文

3.复习大物、线代

本周学习日历

完成状态

基本全部完成

本周学习总结

这周进步了很多了，javaweb的学习真的付诸行动了，不过和javase差不多，没进步很多，但是课程里有html和css，感觉压力小了一点。

计算机天才协会学习周报

本周学习大纲

复习java

本周学习日历

完成状态

基本全部完成

本周学习总结

这周基本没怎么学，五一假期当然是好好玩啦

list

列表，是python的一种数据类型，由一系列按特定顺序排列的元素组成。python包含了多种可对列表进行指定操作的函数方法，以下进行一一介绍。
1、append(obj)
可在list尾部插入指定的元素，使用方法为list.append(obj)。

1
2
3

lst1 = [1,2,3]
lst1.append(4)
print(lst1)   # [1, 2, 3, 4]

append会把obj当成一个整体插入至到list当中.

1
2
3
4

lst1 = [1,2,3]
lst2 =[4,5,6]
lst1.append(lst2)
print(lst1) # [1, 2, 3, [4, 5, 6]]

2、extend(seq)
可在list尾部中追加另一序列中的多个值，seq可以为列表，元组，集合和字

1
2
3
4

lst1 = [1,2,3]
lst2 =[4,5,6]
lst1.extend(lst2)
print(lst1) # [1, 2, 3, 4, 5, 6]

1
2
3
4

lst1 = [1,2,3]
lst3 ={"a":7,"b":8}
lst1.extend(lst3)
print(lst1)  # [1, 2, 3, 'a', 'b']

3、insert(index, obj)
在列表指定位置插入元素，使用方法为list.insert(index,obj)。

1
2
3
4
5
6
7
8

lst1 = [1,2,3]
a = lst1.insert(2,8)
print(lst1) # [1, 2, 8, 3]

lst1 = [1,2,3]
lst2 = {"a":1,"b":2}
a = lst1.insert(3,lst2)
print(lst1)   # [1, 2, 3, {'a': 1, 'b': 2}]

4、pop(index)
删除列表中索引值为index的元素，使用方法为list.pop(index)，index可为空，默认值为-1，即不指定值时删除列表最后一个元素。返回值为删除的元素。

1
2
3
4
5
6

lst1 = [1,2,3]
lst1.pop()
print(lst1)  # [1, 2]
lst1 = [1,2,3]
lst1.pop(1)
print(lst1)#[1, 3]

index（索引值）在列表中不存在时，抛出IndexError: pop index out of range异常。

5、remove(obj)
删除列表中匹配的元素，使用方法为list.remove(obj)，该方法没有返回值。

1
2
3

lst1 = [1,2,3]
re_return = lst1.remove(2)
print(lst1)   # [1, 3]

当列表中包含有多个匹配的元素时，只删除第一个匹配到的元素。

1
2
3

lst1 = [1,2,3,4,2,5,2,6]
re_return = lst1.remove(2)
print(lst1) # [1, 3, 4, 2, 5, 2, 6]

在列表中不存在obj时，抛出异常。

6、clear()
清空列表，该方法没有返回值。

1
2
3
4
5

lst1 = [1,2,3]
re_return = lst1.clear()
print(lst1)

[]

7、index(x[, start[, end]])
返回列表中x元素的索引值，start为开始查找的位置，end为结束查找的位置，start与end可为空，此时则在整个列表中查找。

1
2
3
4
5

lst1 = [1,2,3]
index_num = lst1.index(3)
print(index_num)

2

指定查找开始与结束的位置
若找不到对应的元素，则抛出异常，在索引值为0~1的范围内查找不到“3”这个元素，则抛出异常。

只返回第一次匹配的元素的索引值。

1
2
3
4
5

lst1 = [1,2,3,4,3,6]
index_num = lst1.index(3)
print(index_num)
 
 4

8、count(obj)
统计某个元素在列表中出现的次数。

1
2
3
4
5
6
7
8
9
10
11

lst1 = [1,2,3,4,3,6,3,7,5,3]
count_num = lst1.count(3)
print(count_num)

4

lst1 = [1,2,3,4,3,6,3,7,5,3]
count_num = lst1.count(8)
print(count_num)

0

9、sort(key=None, reverse=False)
对列表进行排序，key为排序的规则，reverse为是否进行降序排列（默认为升序排列），不会生成新的列表，直接在原列表上做改变，使用方法为list.sort()，没有返回值。

9、sort(key=None, reverse=False)
对列表进行排序，key为排序的规则，reverse为是否进行降序排列（默认为升序排列），不会生成新的列表，直接在原列表上做改变，使用方法为list.sort()，没有返回值。

1
2
3
4
5

lst1 = [1,2,4,6,7,5,3]
lst1.sort()
print(lst1)

[1, 2, 3, 4, 5, 6, 7]

key具体可表现为一个函数，即把列表中的元素作为参数传入该函数中，根据函数返回值根据reverse指定的排序方式进行排序。
例子：使用列表每个元素中的第二个字符来比较进行排序

key具体可表现为一个函数，即把列表中的元素作为参数传入该函数中，根据函数返回值根据reverse指定的排序方式进行排序。
例子：使用列表每个元素中的第二个字符来比较进行排序

1
2
3
4
5

lst1 = ["a3","c2","s7","f1","r5"]
lst1.sort(key=lambda x:list(x)[1])
print(lst1)

['f1', 'c2', 'a3', 'r5', 's7']

降序排列

降序排列

1
2
3
4
5

lst1 = ["a3","c2","s7","f1","r5"]
lst1.sort(key=lambda x:list(x)[1],reverse = True)
print(lst1)

['s7', 'r5', 'a3', 'c2', 'f1']

扩展：
sorted(iterable,key=None, reverse=False)
sort一般只应用于列表，sorted可以应用于任何一个可迭代的对象，sorted方法会生成一个新的对象，返回值为排序后的列表，不会影响原对象。
不改变原对象的值

1
2
3
4
5
6
7

lst1 = [1,3,5,4,9]
lst2 = sorted(lst1)
print(lst1)
print(lst2)

[1, 3, 5, 4, 9]
[1, 3, 4, 5, 9]

对字典进行排序时，默认使用字典元素的键（key）进行排序，并返回一个排序后的列表

1
2
3
4
5

lst1 = {"a":2,"c":6,"b":1}
lst2 = sorted(lst1)
print(lst2)

['a', 'b', 'c']

更多关于sorted函数的用法在此不做扩展，在字典操作函数汇总再作详细描述。

10、reverse()
将原列表进行反向排序，直接改变原列表，没有返回值。

1
2
3
4
5
6

lst1 = [1,3,5,4,9]
lst1.reverse()
print(lst1)

[9, 4, 5, 3, 1]

11、copy()
将列表进行浅复制，返回值为复制的新列表。

1
2
3

lst1 = [1,3,5,7,9]
lst2 = lst1.copy()
print(lst2) # [1, 3, 5, 7, 9]

浅复制只复制浅层数据结构，不复制深层数据结构，原列表与复制的新列表会共享深层即子对象，在对任何一个列表子对象进行修改时，会影响另一个列表的子对象内容。

1
2
3
4
5
6
7

lst1 = [1,3,5,7,9,[23,45,36]]
lst2 = lst1.copy()
lst2[5][2] = "gg"
print("lst1:",lst1)
print("lst2:",lst2)
lst1: [1, 3, 5, 7, 9, [23, 45, 'gg']]
lst2: [1, 3, 5, 7, 9, [23, 45, 'gg']]

只修改浅层数据时，不会影响到原列表

只修改浅层数据时，不会影响到原列表

1
2
3
4
5
6
7

lst1 = [1,3,5,7,9,[23,45,36]]
lst2 = lst1.copy()
lst2[2] = "gg"
print("lst1:",lst1)
print("lst2:",lst2)lst1: [1, 3, 5, 7, 9, [23, 45, 36]]
lst2: [1, 3, 'gg', 7, 9, [23, 45, 36]]