day06 6.1 Java基础
day06 6.1 Java基础
【一】Python和Java中的字节与字符串的关系
【1】Java中字节数组与字符串之间的转换关系
字节数组的创建方式一
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
// （1）字节数组与字符串之间的转换关系
byte[] b = new byte[]{'a', 98, 'b'};
// 对象输出不好看
System.out.println(b);
// [B@1b6d3586
// 美化输出 - 强转数据类型
System.out.println(Arrays.toString(b));
// [97, 98, 98]
}
}
字节数组的创建方式二
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
// （1）字节数组与字符串之间的转换关系
// 先声明容器内个数
byte[] b = new byte[3];
// 向容器内放 元素
b[0] = 'a';
b[1] = 98;
b[2] = 'b';
// 对象输出不好看
System.out.println(b);
// [B@1b6d3586
// 美化输出 - 强转数据类型
System.out.println(Arrays.toString(b));
// [97, 98, 98]
}
}
（1）字符串转字节数组
- 在Java中的语法
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
// （2）字符串转字节数组
String name = "蚩梦";
// 转字节 编码
// 不写默认就是utf-8编码
// 相当于Python中的 name.encode('utf-8)
byte[] b = name.getBytes();
// 打印输出
System.out.println(b);
// [B@1b6d3586
// 美化输出
System.out.println(Arrays.toString(b));
// [-24, -102, -87, -26, -94, -90]
}
}
- 在Python中的语法
name = '蚩梦'
b = name.encode('utf-8')
print(b)
# b'\xe8\x9a\xa9\xe6\xa2\xa6'
for item in b:
print(item)
# 232
# 154
# 169
# 230
# 162
# 166
为什么和Java中的字符数组不一样？
Python是无符号的:[0,1,2,3...256]
Java是有符号的:[0,1,2,3...-1,-2,-3...-128]
Java中小于 0 的数组都要加 256
（2）字节数组转字符串
public class Demo01 {
public static void main(String[] args) {
// （3）字节数组转字符串
byte[] b = new byte[]{-24, -102, -87, -26, -94, -90};
// 声明字符串变量接收 b 的返回值
String name = new String(b);
// 打印输出 name
System.out.println(name);
// 蚩梦
}
}
在Java中，要实例化得到一个对象。
必须
new 类名String v1 = new String("dream");
【2】Java中字符数组与字符串之间的转换关系
（1）字符串转字符数组
public class Demo02 {
public static void main(String[] args) {
// 字符数据和字符串之间的转换
// （1）字符串转字符数组
String name = "蚩梦";
// 转成字符数组
char[] c = name.toCharArray();
System.out.println(c);
// 蚩梦
// 数组可以按位置取值
System.out.println(c[0]);
// 蚩
System.out.println(c[1]);
// 梦
}
}
（2）字符数组转字符串
public class Demo02 {
public static void main(String[] args) {
// 字符数据和字符串之间的转换
// （2）字符数组转字符串
// 在Java中单引号 引起来的是字符或者字节
// 在Java中双引号 引起来的是字符串
char[] c = new char[]{'蚩', '梦'};
// 字符数组可以放空字符
char[] d = new char[]{'蚩', '梦', ' '};
String name = new String(c);
String d_name = new String(d);
System.out.println(name);
// 蚩梦
System.out.println(d_name);
// 蚩梦
// System.out.println(name[0]);
// 字符串不支持索引取值
}
}
在Java中单引号 引起来的是字符或者字节
在Java中双引号 引起来的是字符串
【3】Java和Python中的有无符号的问题
（1）Java和Python中的演示
name = '蚩梦'
b = name.encode('utf-8')
print(b)
# b'\xe8\x9a\xa9\xe6\xa2\xa6'
for item in b:
print(item)
# 232
# 154
# 169
# 230
# 162
# 166
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
// （2）字符串转字节数组
String name = "蚩梦";
// 转字节 编码
// 不写默认就是utf-8编码
// 相当于Python中的 name.encode('utf-8)
byte[] b = name.getBytes();
// 打印输出
System.out.println(b);
// [B@1b6d3586
// 美化输出
System.out.println(Arrays.toString(b));
// [-24, -102, -87, -26, -94, -90]
}
}
为什么和Java中的字符数组不一样？
Python是无符号的:[0,1,2,3...256]
Java是有符号的:[0,1,2,3...-1,-2,-3...-128]
Java中小于 0 的数组都要加 256
（2）Java转Python中的字节数组
def java_str_to_python_str(java_str_list):
# 【1】python_str_list = [] # 【1】拿到符合Python语法的字节数组 -----> [232, 154, 169, 230, 162, 166]
python_str_list = bytearray() # 【2】语法：得到的对象支持转码 ----> 蚩梦
for java_str_num in java_str_list:
if java_str_num < 0:
java_str_num += 256
python_str_list.append(java_str_num)
# 【1】return python_str_list
return python_str_list.decode('utf-8') # 【2】
python_str = java_str_to_python_str(java_str_list)
print(python_str)
# [232, 154, 169, 230, 162, 166]
【二】Java中的Object类
【1】Object类可以接受任意类型
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
// 【1】
/*// 先声明了一个字符串类型
String name = "蚩梦";
// 已经声明的类型不支持修改
name = 10;*/
// 【2】
/*// 定义一个数组，数组类型不固定，可以使任意类型
String[] names = new String[]{"蚩梦","痴梦",18};
// 这种方式只能放字符串，不能放其他类型*/
// 【3】
// 定义Object 类型 ----> 类似于Python中的object类，所有类都继承自object
// Java中的所有类，都继承自object，他是所有类的父类
// 根据声明的类 实例化得到对象
Person p = new Person();
Object[] names = new Object[]{"蚩梦", "痴梦", 18, p};
// 这种方式可以放任意类型,甚至是类实例化出的对象
System.out.println(names);
// [Ljava.lang.Object;@1b6d3586
// 强转数据类型 ----> 字符串
System.out.println(Arrays.toString(names));
// 【4】缺点
// 如果是Object类型，不能使用具体类型的方法
System.out.println(names[0]);
// 字符串的有些方法不能使用
// names[0].size()
}
}
// 声明一个类
class Person {
}
好处
定义Object 类型 ----> 类似于Python中的object类，所有类都继承自object
Python中的所有类，都继承自object，他是所有类的父类
这种方式可以放任意类型,甚至是类实例化出的对象
坏处
- 如果是Object类型，不能使用具体类型的方法
【2】Object类型的通用方法
// 1. clone()
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
// 2. getClass()
final方法，返回Class类型的对象，反射来获取对象。
//3. toString()
该方法用得比较多，一般子类都有覆盖，来获取对象的信息。
//4. finalize()
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
//5. equals()
比较对象的内容是否相等
// 6. hashCode()
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
// 7. wait()
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
其他线程调用了该对象的notify方法。
其他线程调用了该对象的notifyAll方法。
其他线程调用了interrupt中断该线程。
时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
// 8. notify()
该方法唤醒在该对象上等待的某个线程。
//9. notifyAll()
该方法唤醒在该对象上等待的所有线程。
/* 常用的
getClass()
toString()
hashCode()
*/
- 所有对象都具有的方法
- getClass()
- 获取具体的类型
- toString()
- 打印显示的样子
getClass()
- 方式一
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
// Object类的常用方法
// （1）把Object转回具体的类型
Person p = new Person();
Object[] names = new Object[]{"蚩梦", "痴梦", 18, p};
System.out.println(names[0].getClass());
// class java.lang.String 返回当前包下的 String 类型
System.out.println(names[3].getClass());
// class Person 返回当前包下的 Person 类型
}
}
// 声明一个类
class Person {
}
- 方式二
import java.sql.SQLOutput;
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
// Object类的常用方法
// （1）把Object转回具体的类型
// 方式一
Person p = new Person();
Object[] names = new Object[]{"蚩梦", "痴梦", 18, p};
System.out.println(names[0].getClass());
// class java.lang.String 返回当前包下的 String 类型
System.out.println(names[3].getClass());
// class Person 返回当前包下的 Person 类型
// 方式二
// 如果不是字符串类型，强转成字符串类型
if (names[0] instanceof String) {
String v1 = (String) names[0];
System.out.println(v1);
// class Person
}
// 如果不是字符串类型，强转成字符串类型
if (names[2] instanceof Integer) {
Integer a1 = (Integer) names[2];
System.out.println(a1);
// 蚩梦
}
// 如果不是Person类型，强转成Person类型
if (names[3] instanceof Integer) {
Person c1 = (Person) names[3];
System.out.println(c1);
// 18
}
}
}
// 声明一个类
class Person {
}
【3】Java中容器类型值List
List 是一个接口
- 接口
- 用来存放多个数据，类似与Python中的列表
接口常见有两种类型
ArrayList
- 底层是基于数组的，但是会自动扩容
LinkedList
- 底层是基于链表的
Java中的接口相当于相当于Python中的父类
Java的数组，只能放、取，不能扩容、删除元素、增加元素
上面的两个接口跟Python中的列表很想，可以放多个元素
ArrayList 和 LinkedList 方法都一样，效率有所区别
ArrayList方法之add
import java.util.ArrayList;
public class Demo04 {
public static void main(String[] args) {
// List 接口类型：ArrayList 和 LinkedList
// ArrayList -----> 内部放的是Object类型
// Java会自动导入需要的包
// 创建方式一
ArrayList l1 = new ArrayList();
// 创建方式二:泛型
// ArrayList<Object> l1 = new ArrayList<Object>();
// 增加元素
// 可以增加任意类型
l1.add("蚩梦");
l1.add("痴梦"); // 增加字符串
l1.add(18); // 增减数组
l1.add(new Dog()); // 增加对象
System.out.println(l1);
// 定义一个 接口只能放字符串类型
ArrayList<String> s1 = new ArrayList<String>();
s1.add("蚩梦");
// s1.add(18) // 不能放数组
// s1.add('18') // 不能放字符
// 只能放字符串类型
}
}
class Dog {
}
LinkedList方法之add
方法同 ArrayList
import java.util.ArrayList;
import java.util.LinkedList;
public class Demo04 {
public static void main(String[] args) {
// List 接口类型：ArrayList 和 LinkedList
// ArrayList -----> 内部放的是Object类型
// Java会自动导入需要的包
// 创建方式一
LinkedList l1 = new LinkedList();
// 创建方式二:泛型
// ArrayList<Object> l1 = new ArrayList<Object>();
// 增加元素
// 可以增加任意类型
l1.add("蚩梦");
l1.add("痴梦"); // 增加字符串
l1.add(18); // 增减数组
l1.add(new Dog()); // 增加对象
System.out.println(l1);
// 定义一个 接口只能放字符串类型
LinkedList<String> s1 = new LinkedList<String>();
s1.add("蚩梦");
// s1.add(18) // 不能放数组
// s1.add('18') // 不能放字符
// 只能放字符串类型
}
}
class Dog {
}
什么是接口
- 接口是用来规范子类行为，Java中不允许多继承
- 实现多个接口，接口只是一个规范，规范了子类有那些方法，但是没有具体实现
/**
* 定义了一个接口：
* 接口规定：有两个方法，speak、run
* 成为我的子类必须实现我定义的两个方法
*/
// 定义接口
interface Duck {
// 接口里面放共同的方法
public void speak();
public void run();
}
// 定义单独的一个类
class TDuck implements Duck {
// 单独的类中有对应的方法
public void speak() {
System.out.println("唐老鸭会说话");
}
public void run() {
System.out.println("唐老鸭会走路");
}
}
// 定义单独的一个类
class RDuck implements Duck {
// 单独的类中有对应的方法
public void speak() {
System.out.println("肉鸭会说话");
}
public void run() {
System.out.println("肉鸭会走路");
}
}
public class Demo05 {
public static void main(String[] args) {
// 什么是接口
// 接口是用来规范子类行为，Java中不允许多继承
// 实现多个接口，接口只是一个规范，规范了子类有那些方法，但是没有具体实现
// 接口的概念
// 实例化两个对象
TDuck t = new TDuck();
RDuck r = new RDuck();
// 接口的类型的变量，可以接收 实现该接口的所有类型
Duck d = t;
d = r;
}
}
List的其他方法
ArrayList 和 LinkedList 相同的方法
import java.util.ArrayList;
public class Demo06 {
public static void main(String[] args) {
// List 其他操作
ArrayList<String> l1 = new ArrayList();
// (1)增加元素
l1.add("蚩梦");
l1.add("痴梦");
l1.add("你好");
l1.add("世界");
l1.add("大虾");
l1.add("排骨");
l1.add("牛肉");
// (2)索引取值
System.out.println(l1.get(0));
// 蚩梦
// (3)修改值
l1.set(0, "萌萌");
System.out.println(l1);
// [萌萌, 痴梦, 你好, 世界]
// (4)删除值(方法重载)
// 按元素删
l1.remove("萌萌");
System.out.println(l1);
// [痴梦, 你好, 世界]
// 按索引删
l1.remove(0);
System.out.println(l1);
// [你好, 世界]
// (5) 是否包含 --- 返回布尔类型
System.out.println(l1.contains("你好"));
// true
// (6) 长度
System.out.println(l1.size());
// (7) 循环
// 基于索引的循环（Python中没有）
for (int i = 0; i < l1.size(); i++) {
System.out.println(l1.get(i));
// 5
//你好
//世界
//大虾
//排骨
//牛肉
}
// 基于迭代的循环（Python中有）
for (String item:l1) {
System.out.println(item);
// 5
//你好
//世界
//大虾
//排骨
//牛肉
}
}
}
LinkedList 多的方法
import java.util.ArrayList;
import java.util.LinkedList;
public class Demo06 {
public static void main(String[] args) {
// List 其他操作
LinkedList<String> l1 = new LinkedList();
// (1)增加元素
l1.add("蚩梦");
l1.add("痴梦");
l1.add("你好");
l1.add("世界");
l1.add("大虾");
l1.add("排骨");
l1.add("牛肉");
// (2)索引取值
System.out.println(l1.get(0));
// 蚩梦
// (3)修改值
l1.set(0, "萌萌");
System.out.println(l1);
// [萌萌, 痴梦, 你好, 世界]
// (4)删除值(方法重载)
// 按元素删
l1.remove("萌萌");
System.out.println(l1);
// [痴梦, 你好, 世界]
// 按索引删
l1.remove(0);
System.out.println(l1);
// [你好, 世界]
// (5) 是否包含 --- 返回布尔类型
System.out.println(l1.contains("你好"));
// true
// (6) 长度
System.out.println(l1.size());
// (7) 循环
// 基于索引的循环（Python中没有）
for (int i = 0; i < l1.size(); i++) {
System.out.println(l1.get(i));
// 5
//你好
//世界
//大虾
//排骨
//牛肉
}
// 基于迭代的循环（Python中有）
for (String item:l1) {
System.out.println(item);
// 5
//你好
//世界
//大虾
//排骨
//牛肉
}
/// ************ LinkedList 多的方法
// (8) 将元素放在首位
l1.push("我是 push");
System.out.println(l1);
// [我是 push, 你好, 世界, 大虾, 排骨, 牛肉]
l1.addFirst("我是 addFirst");
System.out.println(l1);
// [我是 addFirst, 我是 push, 你好, 世界, 大虾, 排骨, 牛肉]
l1.addLast("我是 addLast");
System.out.println(l1);
// [我是 addFirst, 我是 push, 你好, 世界, 大虾, 排骨, 牛肉, 我是 addLast]
}
}
【4】Java中容器类型之Set
- Set 是一个接口
- 常见实现这个接口的类有两个
- 用于实现不重复的多元素集合
- HashSet
- 去重，无序
- TreeSet
- 去重，内部默认排序（ASCII、Unicode）
- 不同的数据类型，无法进行比较
HashSet
- 添加元素
import java.util.HashSet;
public class Demo07 {
public static void main(String[] args) {
// Set 接口下有TreeSet 和 HashSet
// （1）HashSet的使用
// 实例化方式一
// HashSet hs = new HashSet(); // 可以放任意类型
// 实例化方式二
HashSet<String> sh = new HashSet(); // 只能放字符串类型
// 增加元素
sh.add("蚩梦");
sh.add("蚩梦");
sh.add("痴梦");
sh.add("梦梦");
System.out.println(sh);
// 自动去重功能
// [痴梦, 蚩梦, 梦梦]
}
}
- 交集
//import java.util.HashSet;
//import java.util.TreeSet;
//
//public class Demo07 {
// public static void main(String[] args) {
// // Set 接口下有TreeSet 和 HashSet
//
// // （1）HashSet的使用
// // 实例化方式一
// // HashSet hs = new HashSet(); // 可以放任意类型
//
// // 实例化方式二
// TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
//
// // 增加元素
// sh.add("蚩梦");
// sh.add("蚩梦");
// sh.add("痴梦");
// sh.add("梦梦");
// System.out.println(sh);
// // 自动去重功能 且 会进行排序
// // [梦梦, 痴梦, 蚩梦]
//
//
// }
//}
import java.util.HashSet;
import java.util.TreeSet;
public class Demo07 {
public static void main(String[] args) {
// Set 接口下有TreeSet 和 HashSet
// （2）集合的交叉并集
HashSet<String> sh1 = new HashSet<>();
sh1.add("蚩梦");
sh1.add("痴梦");
sh1.add("萌萌");
HashSet<String> sh2 = new HashSet<>();
sh2.add("猛猛");
sh2.add("萌萌");
sh2.add("朦朦");
// (1) 交集
sh1.retainAll(sh2);
System.out.println(sh1);
// 二者的交集只有一个元素 ： [萌萌]
}
}
- 并集
//import java.util.HashSet;
//import java.util.TreeSet;
//
//public class Demo07 {
// public static void main(String[] args) {
// // Set 接口下有TreeSet 和 HashSet
//
// // （1）HashSet的使用
// // 实例化方式一
// // HashSet hs = new HashSet(); // 可以放任意类型
//
// // 实例化方式二
// TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
//
// // 增加元素
// sh.add("蚩梦");
// sh.add("蚩梦");
// sh.add("痴梦");
// sh.add("梦梦");
// System.out.println(sh);
// // 自动去重功能 且 会进行排序
// // [梦梦, 痴梦, 蚩梦]
//
//
// }
//}
import java.util.HashSet;
import java.util.TreeSet;
public class Demo07 {
public static void main(String[] args) {
// Set 接口下有TreeSet 和 HashSet
// （2）集合的交叉并集
HashSet<String> sh1 = new HashSet<>();
sh1.add("蚩梦");
sh1.add("痴梦");
sh1.add("萌萌");
HashSet<String> sh2 = new HashSet<>();
sh2.add("猛猛");
sh2.add("萌萌");
sh2.add("朦朦");
/*// (1) 交集
sh1.retainAll(sh2);
System.out.println(sh1);
// 二者的交集只有一个元素 ： [萌萌]*/
// (2) 并集
sh1.addAll(sh2);
System.out.println(sh1);
// 去重并将全部元素合并到一起 ：[萌萌, 痴梦, 朦朦, 蚩梦, 猛猛]
}
}
- 差集
//import java.util.HashSet;
//import java.util.TreeSet;
//
//public class Demo07 {
// public static void main(String[] args) {
// // Set 接口下有TreeSet 和 HashSet
//
// // （1）HashSet的使用
// // 实例化方式一
// // HashSet hs = new HashSet(); // 可以放任意类型
//
// // 实例化方式二
// TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
//
// // 增加元素
// sh.add("蚩梦");
// sh.add("蚩梦");
// sh.add("痴梦");
// sh.add("梦梦");
// System.out.println(sh);
// // 自动去重功能 且 会进行排序
// // [梦梦, 痴梦, 蚩梦]
//
//
// }
//}
import java.util.HashSet;
import java.util.TreeSet;
public class Demo07 {
public static void main(String[] args) {
// Set 接口下有TreeSet 和 HashSet
// （2）集合的交叉并集
HashSet<String> sh1 = new HashSet<>();
sh1.add("蚩梦");
sh1.add("痴梦");
sh1.add("萌萌");
HashSet<String> sh2 = new HashSet<>();
sh2.add("猛猛");
sh2.add("萌萌");
sh2.add("朦朦");
/*// (1) 交集
sh1.retainAll(sh2);
System.out.println(sh1);
// 二者的交集只有一个元素 ： [萌萌]*/
/*// (2) 并集
sh1.addAll(sh2);
System.out.println(sh1);
// 去重并将全部元素合并到一起 ：[萌萌, 痴梦, 朦朦, 蚩梦, 猛猛]
*/
// (3) 差集
sh1.removeAll(sh2);
System.out.println(sh1);
// 只保留二者不同的元素 ： [痴梦, 蚩梦]
}
}
TreeSet
import java.util.HashSet;
import java.util.TreeSet;
public class Demo07 {
public static void main(String[] args) {
// Set 接口下有TreeSet 和 HashSet
// （1）HashSet的使用
// 实例化方式二
TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
// 增加元素
sh.add("蚩梦");
sh.add("蚩梦");
sh.add("痴梦");
sh.add("梦梦");
System.out.println(sh);
// 自动去重功能 且 会进行排序
// [梦梦, 痴梦, 蚩梦]
}
}
【5】Java中容器类型之Map
- Map 是一个接口
- 用于存储键值对
- 常见实现这个接口的类有两个
- HashMap
- 无序
- TreeMap
- 默认会根据 KEY 排序
HashMap(无序)
- 添加元素
import java.util.HashMap;
import java.util.TreeMap;
public class Demo08 {
public static void main(String[] args) {
// Map 接口： HashMap TreeMap
// HashMap <键的类型，值的类型>
HashMap<String, String> hs = new HashMap();
// 添加元素
hs.put("name", "蚩梦");
hs.put("age", "18");
hs.put("gender", "male");
System.out.println(hs);
// 默认无序
// {gender=male, name=蚩梦, age=18}
}
}
TreeMap(默认排序)
import java.util.HashMap;
import java.util.TreeMap;
public class Demo08 {
public static void main(String[] args) {
// Map 接口： HashMap TreeMap
// HashMap <键的类型，值的类型>
// HashMap<String, String> hs = new HashMap();
TreeMap<String, String> hs = new TreeMap();
// 添加元素
hs.put("name", "蚩梦");
hs.put("age", "18");
hs.put("gender", "male");
System.out.println(hs);
// 默认有序 ： 根据 KEY 排序
// {age=18, gender=male, name=蚩梦}
}
}
公共方法
//import java.util.HashMap;
//import java.util.TreeMap;
//
//public class Demo08 {
// public static void main(String[] args) {
// // Map 接口： HashMap TreeMap
//
//
// // HashMap <键的类型，值的类型>
// // HashMap<String, String> hs = new HashMap();
// TreeMap<String, String> hs = new TreeMap();
//
// // 添加元素
// hs.put("name", "蚩梦");
// hs.put("age", "18");
// hs.put("gender", "male");
//
// System.out.println(hs);
// // 默认有序 ： 根据 KEY 排序
// // {age=18, gender=male, name=蚩梦}
//
// //
//
// }
//}
import java.util.*;
public class Demo08 {
public static void main(String[] args) {
// Map 接口： HashMap TreeMap
TreeMap<String, String> hs = new TreeMap<>();
hs.put("name", "蚩梦");
hs.put("age", "18");
hs.put("gender", "male");
// （1） 移除元素
hs.remove("age");
System.out.println(hs);
// {gender=male, name=蚩梦}
// （2） 大小
System.out.println(hs.size());
// 2
// （3） 获取值
System.out.println(hs.get("name"));
// 蚩梦
// （4） 是否包含
System.out.println(hs.containsKey("name"));
System.out.println(hs.containsValue("蚩梦"));
// true
// true
// （5） 替换
hs.replace("name", "萌萌");
System.out.println(hs);
// {gender=male, name=萌萌}
// （6） 循环
// 方式一 : 以键取值
for (String key : hs.keySet()
) {
System.out.printf("key 是:>>>%s\n", key);
System.out.printf("value 是:>>>%s\n", hs.get(key));
// key 是:>>>gender
// value 是:>>>male
// key 是:>>>name
// value 是:>>>萌萌
}
// 方式二 : 以键值对取值
for (Map.Entry<String, String> item : hs.entrySet()
) {
System.out.println(item.getKey());
System.out.println(item.getValue());
// gender
// male
// name
// 萌萌
}
// 方式三 : 类似于Python中的装饰器
Set s2 = hs.entrySet();
Iterator it3 = s2.iterator();
while (it3.hasNext()) {
// 强转数据类型
Map.Entry mp = (Map.Entry) it3.next();
System.out.println(mp.getKey());
System.out.println(mp.getValue());
// gender
// male
// name
// 萌萌
}
}
}
【三】Java中的面向对象
【1】构造方法
public class Demo09 {
public static void main(String[] args) {
// （1）实例化类得到对象时，无参数会触发无参构造方法
Cat c = new Cat();
// 这是无参构造方法
// 对象调用方法
c.speak();
// 猫说话了!
// （2） 构造方法
// 实例化类得到对象时，传参数会触发有参构造方法
Cat a = new Cat("咪咪", 18);
// 这是有参构造方法
}
}
/**
* 定义类
*/
class Cat {
// 如果 this 想使用某个属性，需要先提前定义
public String name;
public int age;
/**
* 构造方法：无参构造方法，构造方法可以写多个
*/
public Cat() {
System.out.println("这是无参构造方法");
/**
* 在Java中 this 代指 Python中的 self
*/
}
/**
* 构造方法：有参构造方法
*/
public Cat(String name, int age) {
System.out.println("这是有参构造方法");
this.name = name;
this.age = age;
}
// 类添加功能
public void speak() {
System.out.println("猫说话了!");
}
}
【2】静态成员
public class Demo10 {
public static void main(String[] args) {
// 静态成员
// （1）当定义的类中只有有参构造方法时，必须传参数，否则会报错
Snake s = new Snake("dream", 120);
System.out.println(s.name);
// dream
Snake sa = new Snake("萌萌", 150);
System.out.println(sa.name);
// 萌萌
// （2）Python中具有的类属性 类比于 Java中的static修饰
// Java类中的静态成员，对象和类都可以调
// System.out.println(sa.school); // 无法调用，因为没有赋值
// 赋值操作
sa.school = "梦梦学堂";
System.out.println(sa.school);
// 梦梦学堂
System.out.println(s.school);
// 梦梦学堂
// （3）改了类的静态成员，所有对象都受影响
// 类也可以修改静态成员
Snake.school = "萌萌学堂";
System.out.println(sa.school);
// 萌萌学堂
System.out.println(s.school);
// 萌萌学堂
// （4）调用静态方法
// 类调用方法
Snake.speak();
// 小蛇正在嘶嘶嘶~~~
// 对象调用方法
sa.speak();
// 小蛇正在嘶嘶嘶~~~
}
}
class Snake {
/**
* 静态成员：属于类的
*/
public static String school;
/**
* 静态方法
*/
public static void speak() {
// 静态方法
System.out.println("小蛇正在嘶嘶嘶~~~");
}
/**
* 这些成员是属于对象的
*/
public String name;
public int age;
/**
* 有参构造方法
*
* @param name
* @param age
*/
public Snake(String name, int age) {
this.name = name;
this.age = age;
}
}
【3】继承
在 Java 中只允许单继承
public class Demo11 {
public static void main(String[] args) {
// 类实例化得到对象
Chicken c = new Chicken();
// 【1】直接调用 - 没有参数
c.eat();
// 触发 重写方法
// 正在吃东西!
// 父类方法正在被重写
// 【2】调用并传参数 - 触发 重载方法
c.eat("basketball");
// 触发重载方法 进行重载
// 正在吃东西!
// 父类方法正在被重写
// 正在重载方法
}
}
class Base{
public void eat(){
System.out.println("正在吃东西!");
}
}
class Foo{
}
/**
* 只能单继承，不允许多继承
*/
class Chicken extends Base{
// 子类重写父类方法
// 重写：把父类的方法 super 重写了一遍
@Override
public void eat(){
super.eat();
System.out.println("父类方法正在被重写");
}
// 重载 ： 方法同名，但是参数不一样，跟父类没有联系
public void eat(String a){
// 方法可以同名，参数不一样，这个叫重载，跟父类没有联系
System.out.println("正在重载方法");
}
}
【4】小结
- Java中只允许单继承，使用 extends 方法
- 子类中重写父类的方法叫重写
- 方法名相同，但是参数不同，叫重载，跟父类没有必然联系
本文来自博客园，作者：Chimengmeng，转载请注明原文链接：https://www.cnblogs.com/dream-ze/p/17518949.html
浙公网安备 33010602011771号