八期day05-java基础
1 Java环境搭建
# 合伙人---》下次讲
# java：做反编译，发现好多java代码看不太懂，有些加密算法，也不太好破---》接下来的时候，要学习java开发
-找到加密算法---》chat gpt，让它给你写---》转成python---》自己手动调
# java 编译型语言
-java se：java基础---》python中变量定义，函数，面向对象，文件处理，并发，网络编程
-java me:早些年，做手机开发用的，现在弃用了，出了安卓操作系统后，谷歌公司出了安卓sdk，用java代码写
-java ee：做java 的web 方向开发需要学的
-spring框架，springboot，springcloud 基于javaee的标准
-你们如果要做java开发，百分之95以上，都是java ee工程师
# 咱们做安卓开发，只需要学java se即可
# java 集成开发工具包：sdk
-java sdk ：jdk--》23版本---》用1.8 就是8---》现在公司里大量用java8，反编译回来的代码也是java8的代码
-java 开发环境
-jre java运行环境，只要运行java的 jar，war 需要安装这个，但是公司里一般，只允许java程序，也装sdk
-jvm java虚拟机，java是编译型，把源代码编译成字节码文件---》运行再jvm上
-由于不同平台可以装不同平台的jvm虚拟机，于是，java跨平台
# 跨平台
-正常来讲，编译型语言，是不能夸平台的
-c，go(跨平台编译) ---》编译过后，就是当前平台的可执行文件 win：exe linux：可执行文件 mac：可执行文件--》不能夸平台
-开发阶段需要装sdk，运行阶段，不需要装任何东西
-java是个特例---》java编译成中间态[不是可执行文件，字节码文件]---》不能直接运行再操作系统之上----》需要运行再jvm上---》所有运行java程序要有jvm
-java到底是不是编译型语言？
-是，因为有编译，只是没有编译成可执行
-可以这么想象：java编译过后的字节码文件(jar,war包)，运行再jvm上【像python解释器一样的东西】
-解释性语言：python，php，nodejs
-边解释边执行，不需要编译
-无论是写代码还是运行代码，都需要装解释器（源码运行再解释器上）
# java -version
java version "1.8.0_371"
Java(TM) SE Runtime Environment (build 1.8.0_371-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.371-b11, mixed mode)
1.1 安装jdk配置环境变量
# jdk jre jvm
-开发java程序，必须安装jdk，咱们学习的java 8，逆向出来的安卓java的代码，都是转换成java8的代码
-运行java程序，jre
-java字节码文件，运行在jvm上的
# 安装jdk---》很早 给大家了，一路下一步安装即可
# 打开cmd窗口，测试安装是否成功
java -version
javac #如果没有，需要配置环境变量
# 安装jdk时，会提示是否装jre，装不装都可以，因为jdk中包含了jre
# 配置java环境变量，把下面两个路径加入到path中即可
-D:\Program Files\Java\jdk-1.8\bin
-D:\Program Files\Java\jdk-1.8\jre\bin
1.2 第一个helloworld
# jdk安装并配置完成，我们可以开发java代码了
# 把代码写在文件中，新建一个HelloWorld.java 文件，写入
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello world");
}
}
# 移动到D盘根路径，在当前路径下打开命令窗口cmd---》java源代码---》编译成字节码文件
javac HelloWorld.java
# 在当前路径下会生成HelloWorld.class 字节码文件----》不能直接运行在操作系统之上，它需要运行在java虚拟机之上
java HelloWorld
# 打印出 hello world 第一个java程序
1.2 编辑器
# 咱么用记事本写了java程序，顺利运行了，但是总觉得麻烦，以后不可能都用记事本写java，肯定需要选择一款编辑器
#写python 使用pycharm
# java编辑器的选择
### 1 Eclipse https://www.eclipse.org/downloads/
Eclipse是一个免费的开源Java IDE，提供了丰富的功能和插件扩展。它支持Java应用程序、Web应用程序和企业级应用程序的开发，并具有强大的代码编辑、调试和测试工具。
### 2 My Eclipse https://www.genuitec.com/products/myeclipse/
MyEclipse是一个专为Java开发而设计的集成开发环境（IDE），它是Eclipse IDE的一个商业化版本。MyEclipse提供了许多功能和工具，旨在提高Java开发人员的生产力和效率
# 3 IntelliJ IDEA：https://www.jetbrains.com/idea/download/other.html
IntelliJ IDEA是一种商业化的Java IDE，也有免费的社区版可用。它提供了智能代码完成、代码检查和重构等功能，支持Java开发以及其他相关技术，如Spring和Hibernate，同属于Jetbrains系列，使用习惯跟Pycharm类似，我们选择此编辑器
IDEA：是捷克的Jetbrains公司开发的产品，同类型的产品
-Pycharm---》开发python
-Goland---》开发go
-PHPStorm---》开发php
-webstorm---》前端开发
-IDEA---》开发java
AndroidStadio---》如果你用了，你会发现，它根pycharm，或者idea好像，谷歌公司买了它的版权+adt组装成了这个ide--》免费的
# 推荐大家下载：2023.1
ideaIU-2023.1.3.exe---》一路下一步安装
1.2.1 安装-破解
# 软件是收费的，需要破解
# 1 打开.\jihuo-tooll-2023.1\jetbra\scripts
# 2 选择install-current-user.vbs win平台，双击运行，最终提示Done，表示破解完成
-mac平台：install.sh
# 3 打开idea，填入注册码
# 4 点击continue就破解了
1.2.2 新建项目
2 Java语法快速入门
2.1 程序的入口
# java 程序是有入口的，程序从哪里开始执行，区别于python，python 是解释性，可以从任意位置开始执行代码，但是java，go，c都有入口文件
#java中的入口是
# 定义了一个类，名叫 HelloWorld
public class HelloWorld {
# 类中写了一个方法，叫main，这个main方法，必须是public的修饰的，并且是static的，并且没有返回值，是void的，参数是固定的String[] args
public static void main(String[] args) {
System.out.println("hello world2"); # 在控制台打印 一句话
}
}
# java程序必须有 public static void main(String[] args) 如果没有，程序没有入口，就不会执行
2.2 文件名
# java 文件名字，必须遵循如下规范
1 一个java文件中，只能有一个 public 修饰的类，并且这个类名必须跟文件名同名（大小写敏感）
-文件中可以有别的类，但不能用 public 修饰
2 文件中可以有多个类，但是文件名必须跟用public修饰的类同名，不能跟其他类同名
3 如果文件中有多个类，但是无public修饰的类，文件名可以随意
public class Main {
public static void main(String[] args){
System.out.println("hello world");
Demo.add(3,4);
}
}
class Demo{
public static void add(int a,int b){
System.out.println(a+b);
}
}
2.3 类规范
### 1 类名字的规范
类名首字符必须大写，并且使用驼峰方式
python，喜欢用下划线方式，类名有驼峰，变量名，方法名，函数名，py文件名字都用下划线
但是在java中，变量，类名，方法名，java文件名字都要用驼峰
HelloWorld UserInfo ....
### 2 类的修饰符
- public
- default（不写）
### 3 类中成员变量，方法修饰符有
-public：公有的,所有其他类中都可以使用
-private：私有的，只有在当前类中可以使用
-protected：受保护的，只有在当前包下的类中可以使用
-default(不写)：默认
### 4 每行java代码的结尾，必须加 ;
###5 静态成员方法，变量 用static修饰
static修饰的的，等同于python中的类方法，类名直接调用即可
如果不用static修饰，等同于python中的对象方法，需要对象来调用，实例化得到对象，再调用
### 6 viod 表示该方法没有返回值
public void test(){
System.out.println("我是test");
}
public static String test1(){ // 如果写void表示没有返回值，如果有返回值，需要写返回值类型
return "Justin";
}
public class Main {
public static String name = "彭于晏";
public static void main(String[] args) {
// 1 调用其他类的静态方法---》类似于python中的类方法
Demo.add(3, 4);
// 2 调用类自己的静态成员变量
System.out.println(name);
// 3 调用其他类公开的成员变量
System.out.println(Demo.age);
// 4 调用其他类的对象方法，必须实例化才能调用
Demo d = new Demo();
d.test();
}
}
class Demo {
private static String name = "张三"; // 私有变量，只能当前类中使用
public static int age = 19; // 公有变量，所有类都可以使用
public static void add(int a, int b) {
System.out.println(a + b);
System.out.println(name);
}
public void test() {
System.out.println("我是test");
}
}
3 基本语法
3.1 注释
## 1 单行注释
以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方
快捷键：【注释 ctrl+/ 】 【 取消注释 ctrl+/ 】
### 2 多行注释
包含在“ 注释很多行的内容，可以换行
快捷键：【注释 ctrl+shift+/ 】 【取消注释 ctrl+shift+\ 】
### 3 文档注释
包含在“/**”和“*/”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。注释后，鼠标放在类和变量上面会自动显示出我们注释的内容
/**
*
* @param a
* @param b
*/
public static void add(int a, int b) {
System.out.println(a + b);
System.out.println(name);
}
3.2 变量和常量
// 1 定义变量 只能定义一次，不能重复定义
// 变量类型 变量名 = 变量值
String name="Justin";
int age =19;
name="彭于晏";
age=99;
System.out.println(name);
System.out.println(age);
// 2 常量 一旦定义，后期不能改变， python的常量是约定俗称的，可以改
final String hobby="篮球";
//hobby="足球";
System.out.println(hobby);
// 3 final 关键字：
// 可以放在变量前：表示常量，以后不能改
// 放在方法前：这个类可以被子类继承，但是被final修饰的方法不能被重写
// 放在类前：这个类不能被其他类继承了
3.3 输入输出
### 输出：输出到控制台上
###输入，接受控制台的输入
import java.util.Scanner; // 要使用输入，必须导入这个包
public class Demo02 {
public static void main(String[] args) {
// 1 输出
System.out.println("justin is handsome"); // 输出并换行
System.out.print("hello"); // 输出不换行
System.out.print("world"); // 输出不换行
System.out.print("\n"); // 输出不换行
String name = "justin";
System.out.printf("name的值是：%s\n", name); // 字符串格式化
System.out.printf("age的值是：%d\n", 19); // 字符串格式化
// 2 输入，接受控制台的输入 python中 input内置函数 用的很少
System.out.print("请输入您的名字：");
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
System.out.printf("您输入的名字是：%s", input);
}
}
3.4 条件语句
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
System.out.println("请输入您的分数：");
Scanner scanner = new Scanner(System.in);
int score = Integer.valueOf(scanner.nextLine()); // 强制类型转换为int
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 70 && score < 90) {
System.out.println("良好");
} else if (score >= 60 && score < 70) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
}
}
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
System.out.println("请输入您的分数：");
Scanner scanner = new Scanner(System.in);
int score = Integer.valueOf(scanner.nextLine()); // 强制类型转换为int
switch (score){
case 99:
System.out.println("恭喜您99分");
break;
case 88:
System.out.println("恭喜您88分");
break;
default:
System.out.println("不知道多少分");
}
}
}
3.5 循环语句
while循环
// 打印0--9
public class Demo03 {
public static void main(String[] args) {
int count = 0;
while (count < 10) {
System.out.println(count);
count += 1;
}
}
}
do while循环（至少执行1次）
public class Demo03 {
public static void main(String[] args) {
int count = 0;
do{
System.out.println(count);
count++;
}while (count<10);
}
}
for循环
public class Demo03 {
public static void main(String[] args) {
for(int i=0;i<10;i++){
System.out.println(i);
}
}
}
// 循环数组
public class Demo03 {
public static void main(String[] args) {
String[] nameList = {"李易峰", "刘亦菲", "彭于晏", "古天乐"};
for(int i=0;i<nameList.length;i++){
System.out.println(nameList[i]);
}
}
}
break/continue跟其他语言同理
4 数据类型
# 字节类型 byte
# 整数类型：
byte 带符号字节型 8位 -128 ~ 127
short 带符号字节型 16位 -32768 ~ 32767
int 带符号字节型 32位 -231 -2147483648 ~ 2147483647
long 带符号字节型 64位 -263 -9223372036854775808 ~ 9223372036854775807
# 小数类型：浮点型
float
double
# 字符类型 char
# 字符串类型 String
# 数组类型 int[] String[] ...
# 布尔类型 bloon
4.1 字节类型
// byte，字节 【1字节】表示范围：-128 ~ 127 即：`-2^7 ~ 2^7 -1 `
// 单纯的字节类型，一般就是用来表示数字
public class Demo04 {
public static void main(String[] args) {
byte b='A';
System.out.println(b); // 10 进制显示
System.out.println(Integer.toBinaryString(b)); // 2进制显示
System.out.println(Integer.toHexString(b)); // 16进制显示
byte a=98;
System.out.println(a); // 98
System.out.println(Integer.toBinaryString(a)); //2进制显示
System.out.println(Integer.toHexString(a)); // 16进制显示
}
}
// 注意：两个字节相加得到的是int类型，除非强制类型转换成byte类型
byte b=65;
byte a=66;
int c=a+b;
byte d=(byte)(a+b); // 因为有可能加超过byte的范围
System.out.println(c);
System.out.println(d);
python中字符串与字节
##### python中字符串与字节
v1 = '彭于晏'
v2 = v1.encode('utf-8')
print(v2) # b'\xe5\xbd\xad\xe4\xba\x8e\xe6\x99\x8f' 16进制表示
v3 = v1.encode('GBK')
print(v3) # b'\xc5\xed\xd3\xda\xea\xcc' 16进制表示
# 转换为10进制
v3 = [item for item in v2]
print(v3) # [229, 189, 173, 228, 186, 142, 230, 153, 143]
# 转换为二进制
v4 = [bin(item) for item in v2]
print(v4) # ['0b11100101', '0b10111101', '0b10101101', '0b11100100', '0b10111010', '0b10001110', '0b11100110', '0b10011001', '0b10001111']
# 转换为16进制
v5 = [hex(item) for item in v2]
print(v5) # ['0xe5', '0xbd', '0xad', '0xe4', '0xba', '0x8e', '0xe6', '0x99', '0x8f']
java中字符串与字节数组
import java.util.Arrays;
public class Demo04 {
public static void main(String[] args) throws Exception {
String v1 = "彭于晏";
byte[] v2 = v1.getBytes(); // 默认utf-8
System.out.println(v2); // [B@1540e19d 对象形式显示
System.out.println(Arrays.toString(v2)); // [-27, -67, -83, -28, -70, -114, -26, -103, -113]
// GBK
byte[] v22 = v1.getBytes("GBK"); // 默认utf-8
System.out.println(v22); //[B@677327b6
System.out.println(Arrays.toString(v22)); //[-59, -19, -45, -38, -22, -52]
}
}
字节有无符号
# 字节有无符号
Python字节无符号（不含负数）： 0 ~ 255
0 1 2 3 4 5 ... 127 128 129 130 ... 255
Java字节是有符号（含有负数）：-128 ~ 127
0 1 2 3 4 5 ...127 -128 -127 - 126 -125 .... -2 -1
# python:彭于晏
[229, 189, 173, 228, 186, 142, 230, 153, 143]
# java：彭于晏
[-27, -67, -83, -28, -70, -114, -26, -103, -113]
### 编写一个java字节数组转换为python的字符串代码
逻辑是：数字大于0，不操作，小于0，加上256
v1 = [-27, -67, -83, -28, -70, -114, -26, -103, -113]
def java_arr_to_python_str(v1):
num_list = bytearray()
for i in v1:
if i < 0:
i = i + 256
num_list.append(i)
return num_list.decode('utf-8')
if __name__ == '__main__':
print(java_arr_to_python_str(v1))
4.2 整数类型
// byte 带符号字节型 8位 -128 ~ 127
// short 带符号字节型 16位 -32768 ~ 32767
// int 带符号字节型 32位 -231 -2147483648 ~ 2147483647
// long 带符号字节型 64位 -263 -9223372036854775808 ~ 9223372036854775807
byte v1 = 32;
short v2 = 10000;
int v3 = 22221331;
long v4 = 554534353424L;
System.out.println(v1);
System.out.println(v2);
System.out.println(v3);
System.out.println(v4);
4.3 小数类型
# float:单精度
# double：双精度
#表示小数后位数不一样
// 单精度和双精度 表示小数点后位数不一样，double表示多一些
float f=1.123456789012f;
System.out.println(f); //1.1234568
double d=1.12345678901234567d;
System.out.println(d); //1.1234567890123457
4.4 字符类型
char v1 = 'x';
char v2 = '贾';
String v3 = "彭于晏";
4.5 字符串类型
# 双引号引起来的
# 字符串定义
// 1 字符串类型
// String v1 ="justin";
// String v2=new String("hello");
// String v3=new String(new byte[]{98,97,68,'A'}); // 使用字节数组构造字符串
// String v4=new String(new char[]{'中','国'}); // 使用字符数组构造字符串
// System.out.println(v1);
// System.out.println(v2);
// System.out.println(v3);
// System.out.println(v4);
字符串常用方法
String origin = "hello world 中国";
// 1 取指定位置字符
char v1 = origin.charAt(13); // 取出字符 国
System.out.println(v1);
// 2 循环输出每个字符
int len = origin.length(); // 字符串长度
for (int i = 0; i < len; i++) {
char item = origin.charAt(i);
System.out.println(item);
}
// 3 去除前后空白
String v2 = origin.trim(); // 去除空白
System.out.println(v2);
// 4 转大写
String v3 = origin.toLowerCase(); // 小写
System.out.println(v3);
String v4 = origin.toUpperCase(); // 大写
System.out.println(v4);
String[] v5 = origin.split(" "); // 按空格分隔
System.out.println(v5);
String v6 = origin.replace("h", "l"); // 把h替换为l
System.out.println(v6);
String v7 = origin.substring(2, 6); // 子字符串=切片 [2:6]
System.out.println(v7);
boolean v8 = origin.equals("hello world"); // 比较字符串是否相等
System.out.println(v8);
boolean v9 = origin.contains("中"); // 字符串是否包含
System.out.println(v9);
boolean v10 = origin.startsWith("a"); // 字符串是否以xx开头
System.out.println(v10);
String v11 = origin.concat("哈哈哈"); //在字符串末尾追加
System.out.println(v11);
字节数组和字符串相互转换
//1 字符串转字节数组
byte[] b = v4.getBytes(); // 默认utf8形式
System.out.println(b); // 输出对象形式，看不到字节数组
System.out.println(Arrays.toString(b));
// try {
// byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式，需要捕获异常
// } catch (Exception e) {
//
// }
byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式，需要捕获异常,或在方法上 throws Exception
System.out.println(Arrays.toString(b1));
// 2 字节数组转字符串
String v8 = new String(new byte[]{-27, -67, -83, -28, -70, -114, -26, -103, -113});
String v9 = new String(new byte[]{-59, -19, -45, -38, -22, -52},"GBK");
System.out.println(v8);
System.out.println(v9);
字符数组和字符串相互转换
// 1 字符数组转字符串
char[] c=new char[]{'彭','于','晏'};
String v1 = new String(c);
System.out.println(v1);
// 2 字符串串转字符数组
String str1 = "彭于晏";
char[] c=str1.toCharArray();
System.out.println(c.length);
System.out.println(c[0]);
字符串拼接
### 1 直接相加，效率低
String s="hello"+"world"+"中国";
### 2 使用StringBuilder或StringBuffer拼接
StringBuilder sb = new StringBuilder(); // StringBuffer线程安全
//StringBuffer sb = new StringBuffer(); // StringBuffer线程安全
sb.append("hello");
sb.append(" ");
sb.append("world");
sb.append(" ");
sb.append("中");
sb.append("国");
System.out.println(sb.toString());
4.5 数组类型
// 数组类型,定义后长度固定，存放的类型也是固定的，可以放多个值，能取值，能改值，但是不能追加和删除值
String[] names = new String[4]; // 定义了长度为4的String类型数组
names[0] = "彭于晏";
names[1] = "刘亦菲";
names[2] = "迪丽热巴";
System.out.println(names); // [Ljava.lang.String;@1b6d3586
System.out.println(Arrays.toString(names)); // [彭于晏, 刘亦菲, 迪丽热巴, null]
System.out.println(names[1]); // 刘亦菲
int[] numbers =new int[]{2,4,5,2,3}; // 定义并赋初值
System.out.println(Arrays.toString(numbers));
4.6 boolean类型
boolean b = false;
System.out.println(b);
b = true;
System.out.println(b);
if (b) {
System.out.println("b是正确的");
}
