interface List {
public void add(Object data); // 接口中的方法,不写具体的实现,只用于约束。
}
// 类ArrayList实现了接口List,此时这个类就必须有一个add方法。
class ArrayList implements List {
public void add(Object data) {
// 将数据data按照连续存储的方法放在内存。
}
}
// 类LinkedList实现了接口List,此时这个类就必须有一个add方法。
class LinkedList implements List {
public void add(Object data) {
// 将数据data按照链表的形式存储
}
}
List v1 = new ArrayList();
v1.add("一个小黑");
v1.add("麻子");
List v2 = new LinkedList();
v2.add("一个小黑");
v2.add("麻子");
import java.util.LinkedList;
public class Hello {
public static void main(String[] args) {
LinkedList<String> stringList = new LinkedList<String>();
stringList.add("一个小黑"); // 在List尾部添加元素
stringList.push("王二麻子"); // 在List头部添加元素
System.out.println(stringList.size()); // 输出List长度
stringList.set(0, "小潮院长");
for (String tmp : stringList) {
System.out.println(tmp); // 遍历输出List每个元素
}
}
}
import java.util.ArrayList;
import java.util.Iterator;
public class Hello {
public static void main(String[] args) {
ArrayList<String> s1 = new ArrayList<String>();
s1.add("一个小黑");
s1.add("小潮院长");
s1.add("Bilibili");
Iterator<String> it = s1.iterator();
while (it.hasNext()) {
String item = it.next();
System.out.println(item);
}
}
}
import java.util.Iterator;
import java.util.TreeSet;
public class Hello {
public static void main(String[] args) {
TreeSet<String> t1 = new TreeSet<String>();
t1.add("car");
t1.add("banana");
t1.add("apple");
Iterator<String> it = t1.iterator();
while (it.hasNext()) {
System.out.println(it.next()); // 输出顺序 apple, banana, car
}
}
}
上述逆向案例就是定义了一个TreeSet,然后根据一些条件往里面添加元素,然后根据里面的东西做相应的计算。
d = {
"aid": 123,
"xx": 999,
"wid": 888
}
result = "&".join([f'{key}={d[key]}' for key in sorted(d.keys())])
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Hello {
public static void main(String[] args) {
TreeMap<String, String> m1 = new TreeMap<String, String>();
m1.put("name", "一个小黑");
m1.put("age", "18");
m1.put("sex", "男");
// java中的Map类型不能直接转换为迭代器,必须借助Set
Set<Map.Entry<String, String>> s1 = m1.entrySet();
Iterator<Map.Entry<String, String>> it1 = s1.iterator();
while (it1.hasNext()) {
Map.Entry<String, String> entry = it1.next();
String k = entry.getKey();
String v = entry.getValue();
System.out.println(k + ": " + v);
}
// 利用for循环遍历Map
for (Map.Entry<String, String> entry : m1.entrySet()) {
String k = entry.getKey();
String v = entry.getValue();
System.out.println(k + ": " + v);
}
}
}
上述逆向案例利用for循环遍历Map中的键值对,添加到StringBuilder对象中,最后进行MD5加密。
上述逆向案例定义了一个TreeMap v4对象,往里面添加了很多键值对,最后利用StringBuilder讲键值对连接起来,并去掉最后一个’&'字符。
class Person {
// 实例变量
public String name;
public int age;
// 重载构造方法1
public Person() {
this.name = "一个小黑";
this.age = 18;
}
// 重载构造方法2
public Person(String name) {
this.name = name;
this.age = 18;
}
// 重载构造方法3
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 方便打印输出,调试使用
public String toString() {
return this.name + " " + this.age;
}
}
public class Hello {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person("小潮院长");
Person p3 = new Person("小潮院长", 18);
System.out.println(p1); // 一个小黑 18
System.out.println(p2); // 小潮院长 18
System.out.println(p3); // 小潮院长 18
}
}
class Person {
public static String city = "上海"; // 静态变量
public String name; // 实例变量
public Person() {
this.name = "一个小黑";
}
}
public class Hello {
public static void main(String[] args) {
System.out.println(Person.city); // 静态变量通过类名获取
Person p1 = new Person();
System.out.println(p1.name); // 实例变量通过对象获取
}
}
class Base {
...
}
// 单继承
class Son extends Base {
...
}
class Base {
public void add();
}
class Foo {
public void plus();
}
// 实现多个接口
class Son implements Base, Foo {
public void add() {
}
public void plus() {
}
}
// 父类
class Base {
public String email;
public Base(String email) {
this.email = email;
}
public String getSubInfo() {
return String.format("%s", this.email);
}
}
// 子类继承父类
class Person extends Base {
public String name;
public Integer age;
public Person(String name, Integer age, String email) {
super(email);
this.name = name;
this.age = age;
}
public String getInfo() {
return String.format("%s-%d-%s", this.name, this.age, this.email);
}
}
public class Hello {
public static void main(String[] args) {
Person p1 = new Person("一个小黑", 18, "[email protected]");
System.out.println(p1.getInfo()); // 一个小黑[email protected]
System.out.println(p1.getSubInfo()); // [email protected]
}
}
// 父类
class Base {
public String email;
public Base(String email) {
this.email = email;
}
public String getSubInfo() {
return String.format("%s", this.email);
}
}
// 子类继承父类
class Person extends Base {
public String name;
public Integer age;
public Person(String name, Integer age, String email) {
super(email);
this.name = name;
this.age = age;
}
public String getSubInfo() {
return String.format("%s-%d-%s", this.name, this.age, this.email);
}
public String getInfo() {
return String.format("%s-%d-%s", this.name, this.age, this.email);
}
}
public class Hello {
public static void main(String[] args) {
Person p1 = new Person("一个小黑", 18, "[email protected]");
System.out.println(p1.getSubInfo()); // 一个小黑[email protected]
Base b1 = new Base("[email protected]");
System.out.println(b1.getSubInfo()); // [email protected]
// 父类泛指子类,调用父子类共有的方法时,会调用实际子类的方法
Base b2 = new Person("小潮院长", 18, "[email protected]");
System.out.println(b2.getSubInfo()); // 小潮院长[email protected]
// 父类泛指子类,调用子类中新的方法,需要强制类型转换
Base b3 = new Person("杜海皇", 18, "[email protected]");
System.out.println(((Person)(b3)).getInfo()); // 杜海皇[email protected]
}
}
// 接口
interface IMessage {
public void send();
}
class Wechat implements IMessage {
public void send() {
System.out.println("发送微信");
}
}
class DingDing implements IMessage {
public void send() {
System.out.println("发送钉钉");
}
}
class Sms implements IMessage {
public void send() {
System.out.println("发送短息");
}
}
public class Hello {
// 参数用接口,可以泛指实现它的子类
public static void handler(IMessage v1) {
v1.send();
}
public static void main(String[] args) {
Wechat v1 = new Wechat();
DingDing v2 = new DingDing();
Sms v3 = new Sms();
handler(v1); // 发送微信
handler(v2); // 发送钉钉
handler(v3); // 发送短息
}
}
abstract class Base {
// 抽象方法 (约束子类中必须有这个方法)
public abstract void play(String name);
// 普通方法
public void stop() {
System.out.println("Stop");
}
}
class Son extends Base {
public void play(String name) {
System.out.println(String.format("%s is plyaing", name));
}
}
public class Hello {
public static void main(String[] args) {
Base s1 = new Son(); // 抽象类也可以泛指它的子类
s1.play("一个小黑"); // 一个小黑 is plyaing
s1.stop(); // Stop
}
}
src
├── Hello.java
└── utils
└── Helper.java
import utils.Helper;
public class Hello {
public static void main(String[] args) {
System.out.println(Helper.getInfo());
}
}
package utils;
public class Helper {
public static String getInfo() {
return "一个小黑";
}
}
类的修饰符:
类成员修饰符: