Java基础(十)
复习
静态方法与成员方法
//另一个类里的静态和成员方法
public class MyClass {
//静态方法
public static void method2() {
System.out.println("静态方法2执行!");
}
//没有static,这是一个成员方法(实例方法,Instance Method)
public void method3() {
System.out.println("成员方法3执行!");
}
}
/*
* 定义方法的时候,有static和没有static有什么区别?
*
* 有static的方法,叫做静态方法.
* 没有static的方法,叫做成员方法(实例方法).
*
* 定义静态方法的格式:
* public static 返回值类型 方法名称(参数类型 参数名称){
* //方法体
* }
*
* 定义成员方法的格式:
* public 返回值类型 方法名称(参数类型 参数名称){
* //方法体
* }
*
* 调用静态方法的格式:
* 方法名(参数值); //直接调用本类当中的静态方法
* 类名称.方法名(参数值); //调用另外一个类当中的静态方法
* 调用成员方法的格式:
* 类名称 对象名 = new 类名称(); //首先创建对象
* 对象名.成员方法名(参数值); //通过对象名调用成员方法
*
* 1.如果不创建对象,那么通过类名称只能调用静态方法.
* 2.如果创建了对象,那么通过对象名可以调用成员方法.
* 3.通过对象名称也可以调用静态方法,然而不推荐这么做.
*/
public class Demo01StaticVsInstance {
public static void main(String[] args) {
method1(); //调用本类当中的静态方法
//注意:本类当中的静态方法,也可以通过类名称进行调用.
Demo01StaticVsInstance.method1(); //调用本类当中的静态方法
MyClass.method2(); //调用另外一个类当中的静态方法
//需要调用成员方法,就必须借助对象
MyClass obj = new MyClass(); //一定要首先创建一个对象
obj.method3(); //然后才能通过对象去调用成员方法
obj.method2(); //这种写法也可以,但是不推荐!
}
public static void method1() {
System.out.println("静态方法1执行!");
}
}
静态方法的简单使用
//Cook类
public class Cook {
//这是一个静态方法,可以通过类名称进行调用
public static void makeFood(String food) {
System.out.println("将" + food + "做成可口的食物.");
}
}
public class Demo02StaticInvoke {
public static void main(String[] args) {
//希望调用Cook这个类当中的静态方法makeFood
//类名称.静态方法名(参数值)
Cook.makeFood("白菜");
}
}
方法引用
Lambda的冗余场景
//Cook类
public class Cook {
//这是一个静态方法,可以通过类名称进行调用
public static void makeFood(String food) {
System.out.println("将" + food + "做成可口的食物.");
}
}
//保姆接口
public interface Sitter {
//保姆的工作,就是生米煮成熟饭
public abstract void work(String food);
}
/*
* 在某些场景之下,Lambda表达式要做的事情,其实在另外一个地方已经写过了.
* 那么此时如果通过Lambda表达式重复编写相同的代码,就是浪费.
* 那么如何才能复用已经存在的方法逻辑呢?
*/
public class Demo03Lambda {
public static void main(String[] args) {
hireSitter( sitter -> System.out.println("将" + sitter + "做成可口的食物.") );
}
//雇佣一个保姆,并且让他去做饭
public static void hireSitter(Sitter sitter) {
sitter.work("白菜");
}
}
体验方法引用
//Cook类
public class Cook {
//这是一个静态方法,可以通过类名称进行调用
public static void makeFood(String food) {
System.out.println("将" + food + "做成可口的食物.");
}
}
//保姆接口
public interface Sitter {
//保姆的工作,就是生米煮成熟饭
public abstract void work(String food);
}
/*
* 在某些场景之下,Lambda表达式要做的事情,其实在另外一个地方已经写过了.
* 那么此时如果通过Lambda表达式重复编写相同的代码,就是浪费.
* 那么如何才能复用已经存在的方法逻辑呢?
*/
public class Demo03Lambda {
public static void main(String[] args) {
hireSitter( sitter -> System.out.println("将" + sitter + "做成可口的食物.") );
hireSitter( Cook -> makeFood );
}
//雇佣一个保姆,并且让他去做饭
public static void hireSitter(Sitter sitter) {
sitter.work("白菜");
}
}
类名称引用静态方法的格式
//Cook类
public class Cook {
//这是一个静态方法,可以通过类名称进行调用
public static void makeFood(String food) {
System.out.println("将" + food + "做成可口的食物.");
}
}
//保姆接口
public interface Sitter {
//保姆的工作,就是生米煮成熟饭
public abstract void work(String food);
}
/*
* 在某些场景之下,Lambda表达式要做的事情,其实在另外一个地方已经写过了.
* 那么此时如果通过Lambda表达式重复编写相同的代码,就是浪费.
* 那么如何才能复用已经存在的方法逻辑呢?
*
* 如果Lambda表达式需要做的事情,在另外一个类当中已经做过了,那么就可以直接拿过来替换Lambda.
* 方法引用的写法:
*
* 通过类名称引用静态方法,格式:
* 类名称::静态方法名
*/
public class Demo03Lambda {
public static void main(String[] args) {
hireSitter( sitter -> System.out.println("将" + sitter + "做成可口的食物.") );
hireSitter( Cook -> makeFood );
}
//雇佣一个保姆,并且让他去做饭
public static void hireSitter(Sitter sitter) {
sitter.work("白菜");
}
}
类名称引用静态方法的练习
//计算器函数式接口
@FunctionalInterface
public interface Calculator {
//抽象方法的作用:求绝对值(如果是正数或者是0,那么仍然是本身;如果是负数,就要负负为正)
public abstract int getAbs(int num);
}
/*
* JDK当中已经给我们提供好了一个java.lang.Math类.其中有一个静态方法abs就可以实现求绝对值的功能.
* 既然Math.abs方法已经存在了现成的做法,那么我就没有必要在用Lambda自己写一遍了.
* 就可以通过方法引用,直接拿过来用.
*
* 格式:
* 类名称::静态方法名
*/
public class Demo01Abs {
public static void main(String[] args) {
method( num -> {
int result;
if(num >= 0) { //如果是正数或者是0.那么原封不动
result = num;
}else { //否则就是负数,应该负负为正
result = -num;
}
return result;
} );
System.out.println("===============================");
//方法引用的意义:Math类当中有一个abs静态方法,已经有了现成的功能,直接拿过来用.
method(Math::abs);
}
public static void method(Calculator calculator) {
int result = calculator.getAbs(-25);
System.out.println("结果是:" + result);
}
}
对象名引用成员方法的格式
//Cook类
public class Cook {
//这是一个成员方法,必须要有对象才能调用
public void makeFood(String food) {
System.out.println("将" + food + "做成可口的饭菜!" );
}
}
//函数式接口
public interface Sitter {
public abstract void work(String food);
}
/*
* 方法引用的又一种格式:
*
* 通过对象引用成员方法,格式:
* 对象名::成员方法名
*/
public class Demo02MethodRef {
public static void main(String[] args) {
Cook cook = new Cook(); //创建了一个厨师对象
//引用了cook对象当中的成员方法makeFood
method( cook::makeFood );
}
public static void method(Sitter sitter) {
sitter.work("土豆");
}
}
对象名引用成员方法的练习
//函数式接口
@FunctionalInterface
public interface Monitor {
//将参数打印显示出来
public abstract void show(String str);
}
/*
* 问题:既然Lambda就是拿到参数,原封不动的交给println去使用.
* 那么为什么不能直接交给println,而中间不用Lambda?
* Lambda在这种场景当中,要做的事情,就是打印.而打印的功能在println当中已经有了.
*
* 这时候,可以使用方法引用.
* 扩展一点:System.out其实就是一个JDK当中已经创建好的对象,而println就是System.out对象当中的成员方法
*
* 对象名::成员方法名
* System.out.println
*
* 小结:
* 1.一定要有函数式接口,才能使用Lambda.
* 2.对于重复的Lambda场景,可以使用方法引用来进行简化.
*/
public class Demo03Monitor {
public static void main(String[] args) {
//首先使用Lambda,间接调用println方法
useMonitor( (String str) -> {System.out.println(str);} );
//使用方法引用,直接交给了println方法引用去处理
useMonitor(System.out::println);
}
public static void useMonitor(Monitor monitor) {
monitor.show("Hello,World!");
}
}
Stream流
集合for遍历的冗余场景
import java.util.ArrayList;
/*
* 题目:
* 有一个集合里面存放的字符串,样子如:"赵丽颖,98","鹿晗,95","宋小宝,87"
* 要求打印输出所有成绩当中大于90分的数字.
*
* 分析:
* 1.首先定义一个集合ArrayList.存入指定格式的若干个字符串.
* 2.我们只想要逗号后面的,那么就要分割字符串:split,然后取用结果数组当中的1号元素
* 3.根据字符串切割出来的"98"仍然是一个String,需要转换成为int:Interger.parseInt静态方法
* 4.要判断一下转换之后的int是不是大于90,筛选
* 5.对筛选之后的最终结果进行打印输出.
*/
public class Demo01ArrayList {
public static void main(String[] args) {
//首先创建一个集合,然后放入指定格式的字符串
ArrayList<String> recordList = new ArrayList<>();
recordList.add("赵丽颖,98");
recordList.add("鹿晗,95");
recordList.add("宋小宝,87");
//应该拆分一下每个字符串,只要逗号后面的
ArrayList<String> scoreList = new ArrayList<>(); //保存的多个字符串是:"98","95","87"
for (int i = 0; i < recordList.size(); i++) {
String record = recordList.get(i); //当前字符串:"赵丽颖,98"
String[] array = record.split(",");
String score = array[1]; //"98"
scoreList.add(score);
}
//将字符串"98"转换成为int数字98
ArrayList<Integer> numList = new ArrayList<>();//保存的多个数字是:98,95,87
for(int i = 0;i < scoreList.size();i++) {
String score = scoreList.get(i); //"98"
int num = Integer.parseInt(score);
numList.add(num);
}
//过滤一下,筛选,只要大于90的,小于等于90的不要
ArrayList<Integer> resultList = new ArrayList<>(); //最终结果集合
for(int i = 0;i < numList.size();i++) {
int num = numList.get(i); //
if(num > 90) {
resultList.add(num);
}
}
//最后遍历最终结果集合,打印输出
for(int i = 0; i < resultList.size();i++) {
int result = resultList.get(i);
System.out.println(result);
}
}
}
体验Stream的更优写法
import java.util.ArrayList;
/*
* 题目:
* 有一个集合里面存放的字符串,样子如:"赵丽颖,98","鹿晗,95","宋小宝,87"
* 要求打印输出所有成绩当中大于90分的数字.
*
* 分析:
* 1.首先定义一个集合ArrayList.存入指定格式的若干个字符串.
* 2.我们只想要逗号后面的,那么就要分割字符串:split,然后取用结果数组当中的1号元素
* 3.根据字符串切割出来的"98"仍然是一个String,需要转换成为int:Interger.parseInt静态方法
* 4.要判断一下转换之后的int是不是大于90,筛选
* 5.对筛选之后的最终结果进行打印输出.
*/
public class Demo01ArrayList {
public static void main(String[] args) {
//首先创建一个集合,然后放入指定格式的字符串
ArrayList<String> recordList = new ArrayList<>();
recordList.add("赵丽颖,98");
recordList.add("鹿晗,95");
recordList.add("宋小宝,87");
//Stream API更优写法!
recordList.stream().map(s -> s.split(",")[1]).map(Integer::parseInt)
.filter(n -> n > 90).forEach(System.out::println);
}
}
思想概述
获取Stream流的常用方式
import java.util.ArrayList;
import java.util.stream.Stream; /*
* Java 8当中的"流"其实就是Stream接口的对象.
* JDK提供了一个流接口:java.util.stream.Stream<T>
*
* 如何获取流?
* 1.根据集合获取流:集合名称.stream()
* 2.根据数组获取流:Stream.of(数组名称)
*/
public class Demo03GetStream {
public static void main(String[] args) {
//1.根据集合获取流
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("玛尔扎哈"); Stream<String> streamA = list.stream(); //2.根据数组获取流,数组当中的元素必须是引用类型才行
String[] arrayStr = {"Hello","World","Java"};
Stream<String> streamB = Stream.of(arrayStr); Integer[] arrayInteger = {10,20,30};
Stream<Integer> streamC = Stream.of(arrayInteger);
}
}
map映射方法
/*
* 获取流之后,可以使用映射方法:map(用于转换的Lambda表达式)
*
* 映射:就是将一个对象转换成为另一个对象,把老对象映射到新对象上.
*
* "赵丽颖,98" 转换成为 "98" 将一个长字符串转换成为一个短字符串
* "98" 转换成为 98 将一个字符串转换成为一个int数字
*/
public class Demo04StreamMap {
public static void main(String[] args) {
//这个集合当中存放的是字符串类型
ArrayList<String> list = new ArrayList<>();
list.add("100");
list.add("200");
list.add("300"); Stream<Integer> steramA = list.stream().map((String str) -> {
int num = Integer.parseInt(str);
return num;
});
Stream<Integer> steramB = list.stream().map(str -> {
int num = Integer.parseInt(str);
return num;
});
Stream<Integer> steramC = list.stream().map((String str) -> {
return Integer.parseInt(str);
});
Stream<Integer> steramD = list.stream().map(Integer::parseInt);
System.out.println("=========================="); ArrayList<String> list2 = new ArrayList<>();
list2.add("赵丽颖,98");
list2.add("鹿晗,95");
list2.add("宋小宝,87"); Stream<String> stream1 = list2.stream().map((String str) -> {
String[] array = str.split(",");
String result = array[1];
return result;
}); Stream<String> stream2 = list2.stream().map(s -> {
String[] array = s.split(",");
String result = array[1];
return result;
}); Stream<String> stream3 = list2.stream().map(s -> {
String[] array = s.split(",");
return array[1];
}); Stream<String> stream4 = list2.stream().map(s -> {
return s.split(",")[1];
}); Stream<String> stream5 = list2.stream().map(s -> s.split(",")[1]);
}
}
filter过滤方法
import java.util.ArrayList;
import java.util.stream.Stream; /*
* 如果希望对流当中的元素进行过滤,可以使用过滤方法:
*
* filter(能产生boolean结果的Lambda):如果参数Lambda生产了true,则要元素;如果产生了false,则不要元素.
*/
public class Demo05SteramFilter {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(90);
list1.add(85);
list1.add(60); Stream<Integer> stream1 = list1.stream().filter((Integer num) -> {
boolean b = num > 80;
return b;
});
Stream<Integer> stream2 = list1.stream().filter(num -> {
boolean b = num > 80;
return b;
});
Stream<Integer> stream3 = list1.stream().filter(num -> {
return num > 80;
});
Stream<Integer> stream4 = list1.stream().filter(num -> num > 80);
System.out.println("=========================="); ArrayList<String> list2 = new ArrayList<>();
list2.add("赵丽颖");
list2.add("赵丽颖");
list2.add("宋小宝"); Stream<String> streamA = list2.stream().filter((String str) -> {
// boolean b = "赵丽颖".equals(str);
boolean b = str.equals("赵丽颖");
return b;
}); Stream<String> streamB = list2.stream().filter(str -> {
boolean b = str.equals("赵丽颖");
return b;
}); Stream<String> streamC = list2.stream().filter(str -> {
return str.equals("赵丽颖");
}); Stream<String> streamD = list2.stream().filter(s -> s.equals("赵丽颖"));
}
}
forEach遍历方法
import java.util.ArrayList;
import java.util.stream.Stream; /*
* 如果希望在流当中进行元素的遍历操作,可以使用forEach方法:
*
* forEach(Lambda表达式):意思是,对流当中的每一个元素都要进行操作.
* 参数Lambda表达式必须是一个能够消费一个参数,而且不产生数据结果的Lambda.
*
* 例如:
* Lambda: s -> System.out.println(s);
* 方法引用: System::println
*/
public class Demo06SteramForEach {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("玛尔扎哈"); Stream<String> streamA = list.stream();
streamA.forEach((String str) -> {
System.out.println(str);
});
System.out.println("================"); list.stream().forEach((String str) -> {
System.out.println(str);
});
System.out.println("================"); list.stream().forEach(str -> {
System.out.println(str);
});
System.out.println("================"); list.stream().forEach(System.out::println);
}
}
并发的Stream流
import java.util.ArrayList; /*
* 流当中的元素如果特别多,那么只有一个人在逐一,挨个儿处理,肯定比较慢,费劲.
* 如果对流当中的元素,使用多个人同时处理,这就是"并发".
*
* 如何才能获取"并发流"(支持并发操作的流):
* .parallelStream()
*
* 注意事项:
* 1.使用并发流操作的时候,到底有几个人进行同时操作呢?不用管,JDK自己处理.
* 2.只要正确使用,就不会出现多个人抢到同一个元素的情况.
* 3.如果已经获取了一个普通的流,那么只要再调用一下parallel()方法也会变成并发流.
*
* 总结:
* 1.直接获取并发流: .parallelStream()
* 2.已经获取了普通流,然后升级成为并发流: .stream().parallel()
*/
public class Demo07StreamParallel {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
for (int i = 1; i <= 100; i++) {
list.add("Hello-" + i);
} //这是只有一个人在做打印输出的操作
// list.stream().forEach(System.out::println); //获取一个并发流
// list.parallelStream().forEach(System.out::println); //如果已经获取了一个普通的流,那么只要再调用一下parallel()方法也会变成并发流
list.stream().parallel().forEach(System.out::println);
}
}
模块化
思想概述
可以解决的问题
认识module-info.java文件
在Java的一个模块中，需要使用module-info.java文件描述模块信息。
将Eclipse项目改造为模块
可以通过下面的操作将Eclipse的Java Project改造成一个Java9的模块：
1. 点击项目名称，右键选择Configure，点击 Create module-info java 选项。
2. 在生成的module-info.java文件中编写导出exports和依赖requires等信息。
3. 点击项目名称，右键选择Build Path，点选最后一项Configure Build Path。在Projects
标签中选中Modulepath，然后右侧Add所需要依赖的模块。
1. 创建
2. 名字输入
3. 如果有其它模块依赖我,那么其他模块下面的3个包都可以访问
4. 可以访问谁不可以访问谁
设置模块间的依赖关系
知识总结
1. 对比一下静态方法与成员方法的区别：
a） 静态方法与对象无关，可以直接通过类名称调用：
类名称.静态方法名（参数值）；
b） 成员方法一定要有对象才能使用：
对象名.成员方法名（参数值）；
2. 方法引用：如果Lambda表达式想做的事情，在某一个地方某一个方法已经做过了，那么就可以使用方法引用来替代Lambda。
3. 方法引用的方式：
a）通过类名称引用静态方法：类名称::静态方法名
b）通过对象名引用成员方法：对象名::成员方法名
4. Stream 流式思想：简化了普通的集合操作，类似于流水线。Stream流在Java当中就是一个java.util.stream.Stream<T>接口的对象。.
a）如何获取流：
i. 通过集合获取：集合名称stream()
ii. 通过数组获取：Stream.of(数组名称）注意，数组当中必须是引用类型元素
b）映射的方法：map，参数是一个负责转换的Lambda表达式
c）过滤的方法：filter，参数是一个可以产生boolean结果的Lambda表达式
d）遍历的方法：forEach，参数也是一个Lambda，Lambda对应的抽象方法应该只有一个参数并且不产生返回值。
e）如何获取并发流
i. 直接一次性获取并发流：.parallelStream(）
ii. 首先获取普通流，然后继续变成并发流：.stream().parallel()
5. 模块化思想可以为我们带来两点好处:
a） 整体一整个，文件体积太大。如果只是用到了其中的一部分内容，就会浪费。
b） 精确控制package包级别的访问控制。只有导出的包，模块之外才可以访问，否则只能模块内部自己访问。
c） 模块的描述信息module-info.java文件的基本内容：
module本模块的名称{
exports导出的包名称；
requires需要依赖的其他模块名称;
}
Java基础(十)的更多相关文章
- Java基础十二--多态是成员的特点
Java基础十二--多态是成员的特点 一.特点 1,成员变量. 编译和运行都参考等号的左边. 覆盖只发生在函数上,和变量没关系. Fu f = new Zi();System.out.println( ...
- Java基础十--接口
Java基础十--接口 一.接口的定义和实例 /* abstract class AbsDemo { abstract void show1(); abstract void show2(); } 8 ...
- Java基础(十二)--clone()方法
Clone在Java中就是用来复制对象,通过分配一个和源对象相同大小的内存空间,然后创建一个新的对象,那么他和=的区别在哪? 通过=实现对象拷贝: @Data @NoArgsConstructor @ ...
- java基础(十六)----- equals()与hashCode()方法详解 —— 面试必问
本文将详解 equals()与hashCode()方法 概述 java.lang.Object类中有两个非常重要的方法: public boolean equals(Object obj) publi ...
- java基础(十五)----- Java 最全异常详解 ——Java高级开发必须懂的
本文将详解java中的异常和异常处理机制 异常简介 什么是异常? 程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常. Java异常的分类和类结构图 1.Java中的所 ...
- java基础十［包、Jar存档文件和部署］（阅读Head First Java记录）
将Java的class文件生成为可执行的Java应用程序.Java应用程序有三种:完全在本机执行的Jar(例如本机的GUI可执行程序):完全在服务器端远程执行的(例如浏览器来进行存取):介于两者之间的 ...
- 黑马程序员 Java基础<十八>---> 网路编程
--------------- ASP.Net+Android+IO开发S..Net培训.期待与您交流! --------------- 第一 概述 一.概述: 1.网络模型:OSI参考模型和TCP ...
- java基础(十八)----- java动态代理原理源码解析
关于Java中的动态代理,我们首先需要了解的是一种常用的设计模式--代理模式,而对于代理,根据创建代理类的时间点,又可以分为静态代理和动态代理. 静态代理 1.静态代理 静态代理:由程序员创建或特定工 ...
- java基础(十)-----Java 序列化的高级认识
将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java 系列技术中一个较为重要的技术点,在大部分情况下,开发人员只需要了解被序列化的类需要实现 Serializable 接口,使用 ...
- java基础(十四)-----详解匿名内部类——Java高级开发必须懂的
在这篇博客中你可以了解到匿名内部类的使用.匿名内部类要注意的事项.匿名内部类使用的形参为何要为final. 使用匿名内部类内部类 匿名内部类由于没有名字,所以它的创建方式有点儿奇怪.创建格式如下: n ...
随机推荐
- learning armbian steps(10） ----- armbian 源码分析（五）
在上一节的分析当中,已经知道了uboot kernel的源代码路径及编译选项,以及rootfs的版本,相关信息如下所示: ## BUILD CONFIGURATION Build target: Bo ...
- HGOI 20190828 题解
Problem A 数学题 设数论函数$f(x)$表示$x(x ∉ Prime)$的次大因数, 给出$l,r$求出$\sum\limits_{i=l,i ∉ Prime} ^r f(i)$ . 对于$ ...
- 大体知道java语法2----------理解面向对象
我参加过大大小小n场面试,被好几位面试官问到过:能不能谈谈面向对象的几大特征?什么是面向对象?对于这两个问题,我始终觉得一定要理解,其实不只是这种概念题(姑且算它是概念题吧),包括各种语法都应该去理解 ...
- vue项目中主要文件的加载顺序（index.html、main.js、App.vue）
todo: https://www.cnblogs.com/xifengxiaoma/p/9493544.html https://www.cnblogs.com/stella1024/p/10563 ...
- HDU 5806 NanoApe Loves Sequence Ⅱ ——（尺取法）
题意:给出一个序列,问能找出多少个连续的子序列,使得这个子序列中第k大的数字不小于m. 分析:这个子序列中只要大于等于m的个数大于等于k个即可.那么,我们可以用尺取法写,代码不难写,但是有些小细节需要 ...
- $\LaTeX$数学公式大全9
$9\ Math\ mode\ accents$ $\acute{a}$ \acute{a} $\breve{a}$ \breve{a} $\ddot{a}$ \ddot{a} $\grave{a}$ ...
- legend3---6、legend3爬坑杂记
legend3---6.legend3爬坑杂记 一.总结 一句话总结: 学东西不做项目也学不到深处,其实也就是学了没理解透, 1.lavarel中模型关联可以用的实质是? lavarel在数据库中插入 ...
- HearthBuddy卡牌无法识别
界面上无法识别,提示是 [Unidentified card ID :DAL_010][Unidentified card ID :DAL_415] Unidentified card ID :HER ...
- Android热修复技术原理详解
阿里Dexposed -- native解决方案 原理: 直接在native层进行方法的结构体信息对换,从而实现完美的方法新旧替换,从而实现热修复功能 他的思想完全来源于Xposed框架,完美诠释 ...
- 生成ip地址表的不同姿势--脚本生成和echo命令生成
前段时间参加了几个线下的靶机攻防比赛,几十个队伍,如果攻击的时候一个个攻击就非常麻烦,浪费时间.所以需要批量攻击.批量攻击就需要一个完整的ip地址表.在这里总结一下... 有不足的地方欢迎评论 一.脚 ...