【来杯JAVA冷静一下】_01基础_0805
0805 来杯JAVA冷静一下
java复习笔记
感谢狂神说java。
1 如何更好更高效的学习Java
- 多写(代码)，多写(笔记)，多写(文章)多练(交流)，
- 多练(思维)，多练(技能)
- 多分享(知识)，多提问(怎么了)，多思考(为什么)
- 最重要(坚持)
**每个牛B人物背后都有段苦逼的岁月，只要像sb的一样坚持，终将牛B!
**
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4vytkf97-1691320918893)(media/16912011902532/16912063137591.jpg)]
核芯显卡与外接显卡，前者目的是让电脑能用，后者是为了使用体验加分
2 计算机硬件
些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
计算机硬件组成：
在这里插入图片描述
CPU
主板
内存
电源、主机箱
硬盘
显卡
键盘、鼠标
显示器
等…
3 计算机软件
计算机软件可以使计算机按照事先预定好的顺序完成特定的功能计算机软件按照其功能划分为系统软件与应用软件
系统软件:
DOS(Disk Operating System), Windows, Linux, Unix, Mac, Android, ios
应用软件:
WPS，QQ，微信，英雄联盟，绝地求生…
软件、开发、软件开发
人机交互 (图形化界面，命令行 )
定
IntelliJ IDEA
3 mac快捷键
4 MacOS 常用终端dos命令大全
常用的命令行的操作：
pwd 。 cd 。 cd … mk dir rm
echo xxx>xxx.txt
echo xxx>xxx.java
javac xxx.java 编译源文件
java xx。class 运行字节码文件
md 。
rd
cd
del xxx
应用程序=算法+数据结构
MacOS 常用终端命令大全：
touch xxx.doc
rm xxx.doc
1 目录操作
命令——功能描述——示例
mkdir——创建一个目录——mkdir dirname
rmdir——删除一个目录——rmdir dirname
mvdir——移动或重命名一个目录——mvdir dir1 dir2
cd——改变当前目录——cd dirname
pwd——显示当前目录的路径名——pwd
ls——显示当前目录的内容——ls -la
dircmp——比较两个目录的内容——dircmp dir1 dir2
2 文件操作
命令——功能描述——示例
cat——显示或连接文件————cat filename
pg分页格式化显示文件内容——pg filename
more——分屏显示文件内容——more filename
od——显示非文本文件的内容——od -c filename
cp——复制文件或目录——cp file1 file2
rm——删除文件或目录——rm filename
mv——改变文件名或所在目录——mv file1 file2
ln——联接文件——ln -s file1 file2
find——使用匹配表达式查找文件——find . -name “*.c” -print
file——显示文件类型——file filename
open——使用默认的程序打开文件——open filename（open . 打开当前目录）
3 选择操作
命令——功能描述——示例
head——显示文件的最初几行——head -20 filename
tail——显示文件的最后几行——tail -15 filename
cut——显示文件每行中的某些域——cut -f1,7 -d: /etc/passwd
colrm——从标准输入中删除若干列——colrm 8 20 file2
paste——横向连接文件——paste file1 file2
diff——比较并显示两个文件的差异——diff file1 file2
sed————非交互方式流编辑器——sed “s/red/green/g” filename
grep——在文件中按模式查找——grep “1” filename
awk——在文件中查找并处理模式——awk ‘{print 111}’ filename
sort——排序或归并文件——sort -d -f -u file1
uniq——去掉文件中的重复行——uniq file1 file2
comm——显示两有序文件的公共和非公共行——comm file1 file2
wc——统计文件的字符数、词数和行数——wc filename
nl——给文件加上行号——nl file1 >file2
4 安全操作
命令——功能描述——示例
passwd——修改用户密码——passwd
chmod——改变文件或目录的权限——chmod ug+x filename
umask————定义创建文件的权限掩码——umask 027
chown——改变文件或目录的属主——chown newowner filename
chgrp——改变文件或目录的所属组——chgrp staff filename
xlock——给终端上锁——xlock -remote
5 编程操作
命令——功能描述——示例
make——维护可执行程序的最新版本——make
touch——更新文件的访问和修改时间——touch -m 05202400 filename
dbx——命令行界面调试工具——dbx a.out
xde——图形用户界面调试工具——xde a.out
6 进程操作
命令——功能描述——示例
ps——显示进程当前状态——ps u
kill——终止进程——kill -9 30142
nice——改变待执行命令的优先级——nice cc -c *.c
renice——改变已运行进程的优先级——renice +20 32768
7 时间操作
命令——功能描述——示例
date——显示系统的当前日期和时间——date
cal——显示日历——cal 8 1996
time——统计程序的执行时间——time a.out
8 网络与通信操作
命令——功能描述——示例
telnet——远程登录——telnet hpc.sp.net.edu.cn
rlogin——远程登录——rlogin hostname -l username
rsh——在远程主机执行指定命令——rsh f01n03 date
ftp——在本地主机与远程主机之间传输文件——ftp ftp.sp.net.edu.cn
rcp——在本地主机与远程主机 之间复制文件——rcp file1 host1:file2
ping——给一个网络主机发送 回应请求——ping hpc.sp.net.edu.cn
mail——阅读和发送电子邮件——mail
write——给另一用户发送报文——write username pts/1
mesg——允许或拒绝接收报文——mesg n
9 Korn Shell 命令
命令——功能描述——示例
history——列出最近执行过的 几条命令及编号——history
r——重复执行最近执行过的 某条命令——r -2
alias——给某个命令定义别名——alias del=rm -i
unalias——取消对某个别名的定义——unalias del
10 其它命令
命令——功能描述——示例
uname——显示操作系统的有关信息——uname -a
clear——清除屏幕或窗口内容——clear
env——显示当前所有设置过的环境变量——env
who——列出当前登录的所有用户——who
whoami——显示当前正进行操作的用户名——whoami
tty——显示终端或伪终端的名称——tty
stty——显示或重置控制键定义——stty -a
du——查询磁盘使用情况——du -k subdir
df——显示文件系统的总空间和可用空间——df /tmp
w——显示当前系统活动的总信息——w
11 一些常用技巧
所以你可以使用▲（上箭头）或▼（下箭头）来上下移动，使用 空格键 来翻页，输入/和关键字来按照关键字搜索按Q来退出使用指南页面tab按键自动补全唯一路径中止一个错误的或者发疯的命令，可以使用组合键control + C。你可以在执行前编辑命令，只需要使用箭头和键盘上的其他字母。没有输入任何命令时，你可以用▲和▼来浏览历史命令。同样可以编辑和再次执行。你也可以使用history命令查看历史记录。你可以使用组合键control + L清屏。
5 计算机语言发展史
第一代语言 机器语言
计算机的基本计算方式都是基于二进制的方式
二进制机器语言:010111001010110010110100
这种代码是直接输入给计算机使用的，不经过任何的转换!
第二代语言 汇编语言
- 解决人类无法读懂机器语言的问题
- 指令代替二进制
- 目前应用 :
逆向工程
机器人
病毒
codesg segment
start:
mow ax， 0123h;寄存器送入值
mov bx， 0457h
add ax, bx; ax + bx 寄存器值相加
add ax, ax;算 ax 的平方
mov ax, 4c00n
int 21h ;结束返回
codesg ends
end start ; 指定程序入口标号为 start
第三代语言 摩尔定律 高级语言
当价格不变时，集成电路上可容纳的晶体管数目，约每隔18个月便会增加一倍，性能也将提升一倍。换言之，每一美元所能买到的电脑性能，将每隔18个月翻两倍以上
第三代语言
- 高级语言
- 大体上分为:面向过程和面向对象两大类.C语言是典型的面向过程的语言。C++、JAVA是典型的面向对象的语言,
聊聊各种语言:
C语言(所有高级语言的鼻祖 + 汇编语言)
C++语言（C语言的升级版，C语言面向对象的版本 ）
JAVA语言（基于C和C++，又被称为 C+±-，把C++中不好的–了）
C#语言（Csharp）比尔盖茨微软 发明的语言，目的是代替java语言。c#还是有点用的，unity开发要学学
Python、PHP、JavaScript
MATLAB
C#net
python
6
JavaScript
Java
oaao
java入门
1 C& C++
1972年C诞生
- 贴近硬件，运行极快，效率极高。
- 操作系统，编译器，数据库，网络系统等
- 指针和内存管理
1982年C++诞生
- 面向对象
- 兼容C
- 图形领域、游戏等
2 反抗
我们要建立一个新的语言:
- 语法有点像C
- 没有指针
- 没有内存管理
- 真正的可移植性，编写一次，到处运行
- 面向对象
- 类型安全
- 高质量的类库
3 Java初生
三高：高可用 高性能 高并发
缺乏互动性。1995年的网页简单而粗糙图形界面的程序(Applet)
Bill Gates说:这是迄今为止设计的最好的语言!
- Java 2 标准版(J2SE): 去占领桌面
- Java 2 移动版(J2ME): 去占领手机
- Java 2 企业版(J2EE): 去占领服务器
大量的巨头加入
4 Java发展 （天生为服务器诞生）
他们基于Java 开发了巨多的平台，系统，工具
- 构建工具: Ant，Maven,Jekins
- 应用服务器: Tomcat，Jetty,Jboss,Websphere,weblogic
- Web开发: Struts,Spring,Hibernate, myBatis 开源的框架
- 开发工具:Eclipse, Netbean,intellij idea, Jbuilder
2006 :(大数据领域)Hadoop
2008 :hadoop Android(手机端) 运行在安卓之上的正是java
99%的程序员都是会java，精通java得可能只有1%。
微软：.NET 服务器端 开发工具Visual Studio Code VS SQL server
5 Java特性与优势
简单性
面对对象
可移植性（一次编写，到处运行 windos linix macOS 不用管操作系统和硬件问题。 write once run anywhere 一个bug 到处运行 ）
高性能
分布式
动态性（反射机制）
多线程
安全性
健壮性
6 Java三大版本
Write Once，Run Anywhere
一个bug 到处运行
简而言之:跨平台但不能交叉编译
JVM：java虚拟机，跨平台。
- JavaSE: 标准版 (桌面程序，控制台开发…)
- X 已废弃 JavaME: 嵌入式开发 (手机，小家电…)，已经凉了
- JavaEE: E企业级开发 (Web端，服务端开发…)，JavaSE为基础
EE的基础是SE
7 JDK JRE JVM
JDK：Java Development Kit (Java开发者工具，包括 JRE，JVM)
JRE：Java Runtime Environment (Java运行时环境)
JVM：Java Virtual Machine (Java虚拟机，跨平台核心)
Java基础
hello world ：
public class HelloWorld0802 {
public static void main(String[] args) {//psvm
System.out.println("hello 230802 world！");//sout
}
}
1 注释
单行注释 //
多行注释 /* /
文档注释 /* */
2 标识符和关键字
1 51个关键字
Java 语言目前定义了 51 个关键字，这些关键字不能作为变量名、类名和方法名来使用。
以下对这些关键字进行了分类。
- 数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
- 流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
- 修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
- 动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
- 保留字：true、false、null、goto、const。
2 标识符
Java 所有的组成部分都需要名字。类名、变量名、方法名都被称为标识符
标识符注意点
所有标识符都应该以 字母、 ( 美元符 ) 、 ( 下划线 ) 开头首字母之后可以是字母、 (美元符)、_(下划线) 开头 首字母之后可以是 字母、 (美元符)、(下划线)开头首字母之后可以是字母、、_ 或数字任何字符组合
标识符可以包含关键字，但不能与关键字重名。
例如以下合法与不合法标识符。
合法标识符：date、KaTeX parse error: Expected group after '_' at position 13: 2011、_date、D_̲date 等。
不合法的标识符：123.com、2com、for、if 等。
关键字不能作为变量名或方法名
标识符大小写敏感
String Man
String man 不同
可以用中文命名，但不建议使用，即使用拼音命名也Low
String 王者荣耀
3 数据类型
public class HelloWorld0802 {
public static void main(String[] args) {
String a="10";
int num= 9;
System.out.println("str:"+a);
System.out.println("num:"+num);
}
}
//str:10
//num:9
- 强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用 - 弱类型语言：JavaScript，Python
Java的数据类型分为两大类
基本类型（primitive type），有8大基本类型，此外都是引用类型
引用类型（reference type）
1 基本类型（primitive type）
//整数
int num1 = 10; //最常用，只要别超过21亿（2^31-1）
byte num2 = 20; //-128~127
short num3 = 30;
long num4 = 30L;
//long类型数字后面要价格L（尽量用大写，小写l容易与1搞混）
//字符
char ch = '张';
//String不是关键字，是类
//小数：浮点数
float num5 = 50.1F; //float类型数字后面要加个F
double num6 = 3.141592653589793238;
//布尔值：是非
boolean flag = true
##### 什么是位/字节
- 数据存储是以“字节”（Byte）为单位，
- 数据传输大多是以“位”（bit，又名“比特”）为单位，一个位就代表一个0或1（即二进制），每8个位（bit，简写为b）组成一个字节（Byte，简写为B），是最小一级的信息单位 。
1 bit 1位 = 一个0/1，数据储存的最小单位，
0000 0000 八位的二进制数 8bit = 1 字节 1byte ，数据储存、处理的基本单位 。 习惯用大写B 来表示：
1 B （1byte，字节） = 8bit （位）
- 位 (bit) : 是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数.字节(byte) : 是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示
1B (byte,字节) = 8bit (位)
- 字符:是指计算机中使用的字母、数字、字和符号
- 1bit表示1位
- 1Byte表示一个字节 1B=8b.
- 1024B=1KB
- 1024KB=1M
- 1024M=1G.
思考: 电脑的32位和64位的区别是什么呢?
地址线宽度的不同 ，就是地址总线的宽度。
```java
public class HelloWorld0802 {
public static void main(String[] args) {
int i = 10;
int i2 = 010; //人进制@0~9 A~F 16
int i3 = 0x10;//一六进制
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
float f = 0.1f; //@.1
double d = 1.0 / 10; //@.1
System.out.println(f ==d);
float d1 = 3456758786754f;
float d2 = d1+1;
System.out.println(d1==d2);
}
}
/*
10
8
16
false //最好完全避免适应浮点数进行比较
true//最好完全避免适应浮点数进行比较
*/
### //fLoat//doubLe有限 离散舍入误差 大约 接近但不等于
#### 4 数据类型 拓展 及面试题
```java
public class HelloWorld0802 {
public static void main(String[] args) {
int i = 10;
int i2 = 010; //人进制@0~9 A~F 16
int i3 = 0x10;//一六进制
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
float f = 0.1f; //@.1
double d = 1.0 / 10; //@.1
System.out.println(f ==d);
float d1 = 3456758786754f;
float d2 = d1+1;
/*
i = 10
i2 = 8
i3 = 16
f = 0.1
d = 0.1
但是 相等？：false
*/
System.out.println(d1==d2);
}
}
/*
8
16
false
true
*/
public class HelloWorld0802 {
public static void main(String[] args) {
//所有的字符本质还是数字
//编码 Unicode 表:(97 = a 65 =A) 2字节 - 65536Excel
//U0000 UFFFF
char c3 = '\u0061';
System.out.println("c3：'\\u0061' "+c3); //a
//转义字符
//制表符
// lt
// \n 换行
// ....
System.out.println("Hello\nWorld");
}
}
public class HelloWorld0802 {
public static void main(String[] args) {
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa == sb);
//很常见的一个面试题：==和equals的区别:字符串常量池
//String 是引用类型的变量 是类 new 则开辟一块内存空间
//如果比较的对象是基本数据类型，则比较的是数值是否一致；
// 如果比较的是引用数据类型，则比较的是对象的地址值是否一致。
//即：基本类型比较值的内容是否一样，引用类型比较地址值。
String sc = "hello world";
String sd = "hello world";
System.out.println(sc == sd);
//从对象 内存分析
//布尔值扩展
boolean flag = true;
if (flag == true) {
System.out.println("新手写法true");
}//等于下面，（） 默认判断是否为真
if (flag) {
System.out.println("默认判断是否为真");
}
}
}
5 类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
容量低–>高：
byte, short,char -> int -> long -> float -> double
运算中，不同类型的数据先转化位同一类型，再进行运算。
- 强制转换，（类型）变量名，容量由高到低
- 自动转换，容量由低到高
//强制转换 （类型）变量名 高--低
//自动转换 低--高
//byte, short,char -> int -> long -> float -> double
int i = 128;
byte b = (byte)i; //强制转换 内存溢出 -128~127
double d = i; //自动转换
System.out.println(i); //128
System.out.println(b); //-128
System.out.println(d); //128.0
/*
注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容器转换到低容量的时候，强制转换
4.可能存在内存溢出，或者精度问题
*/
byte, short,char -> int -> long -> float -> double
//double到int 高到低
System.out.println((int)23.7); //23丢失精度
char c = 'a';// char< int 好事 自动提升容量 字符自动提升为int数字
int n = c+1;
System.out.println(n); //98
//但是 当int 数字 向下转换为 char
System.out.println((char)n); //b
//当操作数比较大时，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000; //10亿，下划线不会被打印出来
System.out.println(money); //1000000000
int years = 20;
int total = money*years; //数据大，溢出
System.out.println(total); //-1474836480
long total2 = money*years; //默认是int，转换前就有溢出问题
System.out.println(total2); //-1474836480
long total3 = money*(long)years; //先把一个数转Long
System.out.println(total3); //20000000000
//因为int和long运算时自动转成了long，而不加(long)是默认两个int运算后再转long
6 变量、常量、作用域
变量
- 变量是什么：就是可以变化的量
- Java是一种强类型语言，每个变量都必须声明其类型
- Java变量是程序中最基本的存储单元，要素包括变量名，变量类型和作用域
//数据类型 变量名 = 值;
type varName [=value][{,varName[=value]}];
//可以使用逗号隔开多个类型的变量，但不建议在一行定义多个变量
查看方法：command+点击
【变量作用域】 ！！重要：代码结构
- 类变量（static）
- 实例变量
- 局部变量
public class Variable{
static int allClicks = 0; //类变量
String str = "hello world"; //实例变量
public void method(){
int i = 0; //局部变量
}
}
//一个公共类 HelloWorld0802 在类内定义方法（main方法）、属性
public class HelloWorld0802 {
//类变量 static
static double salary = 2500;//int 自动向上转换为了 double类型
//属性: 变量
//实例变量:从属于对象;
//实例变量:从属于对象，如果不自行初始化，这个类型的默认值 0.0 u0000
//布尔值 默认是false
//除了基本类型，其余的都是null 例如 类String 的name 就是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量，在方法{}里，必须声明和初始化值 {}括号外就是全局变量咯
int i = 10;
System.out.println(i);
//变量类型 除了8中基本类型 也可以自己定义类型
// 格式：基本类型 变量名字 = new HelloWorld0802();
//如何创建一个类的实例对象
// 要新建类的对象，再通过对象名去点他，引用。而且还要写set get方法
//new，相当于拿到了类HelloWorld0802， 就是在内存中开辟了一块空间，可以对里面的数据进行操作
// 返回一个对象，并被实例对象 demo08接收
// 格式：基本类型 变量名字 = new HelloWorld0802();
HelloWorld0802 demo08 = new HelloWorld0802();
System.out.println(demo08.name);
System.out.println(demo08.age);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add() {
}
}
常量
常量：初始化后不能再改变的值，不会变动的值。
可以理解为一种特殊的变量，其值被设定后，在程序运行过程不允许被更改。
//常量一般用大写字符final 常量名=值; final double PI = 3.14;
//修饰符 不存在先后顺序，static可以写final后面 static final double PI=3.14; //类变量，该类下的全局范围
ps。java 修饰符号
在Java编程中，修饰符（modifiers）用于修改类、方法、变量等的行为和特性。Java中的修饰符有很多种，以下是一些常用的修饰符：
1 访问修饰符（Access Modifiers）：
public：可以被任何其他类访问。
protected：可以被同一包内的类以及子类访问。
default（默认，不写修饰符）：只能被同一包内的类访问。
private：只能被同一类内部访问。
2 非访问修饰符（Non-Access Modifiers）：
static：用于创建类级别的成员，而不是实例级别的成员。
final：标记为不可更改，可以用于类、方法和变量。
abstract：用于抽象类和抽象方法，不能被实例化。
synchronized：用于同步方法或代码块，控制多线程访问。
volatile：用于标记变量为易变的，用于多线程场景。
transient：用于标记变量不会被序列化，通常用于Serializable对象。
native：表示方法是由本地代码实现的，用于与本地库进行交互。
strictfp：用于保持浮点数运算在不同平台上的一致性。
代码示例：
public class Example {
public int public Variable; // 公共访问修饰符
protected int protected Variable; // 保护访问修饰符
int default Variable; // 默认访问修饰符
private int private Variable; // 私有访问修饰符
static int static Variable; // 静态修饰符
final int final Variable = 10; // final修饰符
synchronized void syncMethod() { // synchronized修饰符
// 同步代码块
synchronized (this) {
// ...
}
}
abstract void abstract Method(); // abstract修饰符
public static void main(String[] args) {
Example example = new Example();
example.publicVariable = 5;
example.protectedVariable = 10;
example.defaultVariable = 15;
example.privateVariable = 20;
}
}
变量的命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写+驼峰原则：lastName
- 局部变量：首字母小写+驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写+驼峰原则：Man，GoodMan
- 方法名：首字母小写+驼峰原则：run(),fastRun()
7 运算符
-
算术运算符:+，-，*，/，% （模运算 取余数 11/5=2…1），++，–
-
赋值运算符 = （a = 10 ； 把10 赋值给a）
-
关系运算符: >，<，>=,<=，==，!=,instanceof
-
与或非 逻辑运算符: &&，||，!
-
位运算符:&，｜，^，～，>>，<<,>>>(了解!!! )
-
条件运算符 ? :
-
扩展赋值运算符:+=，-=，*=，/=
- 算术运算符:+，-，*，/，% （模运算 取余数 11/5=2…1），++，–
public class Demo01 {
public static void main(String[] args) {
long a = 123123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a + b + c + d);
//Long
System.out.println(b + c + d); //Int
System.out.println((c + d)); //Int
System.out.println((double) (c + d)); //double
}
}
% （模运算 取余数 11/5=2…1）
- 关系运算符: >，<，>=,<=，==，!=,instanceof
// 输出的一定是布尔值 true false
// if
public class Demo01 {
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
int c = 22 ;
System.out.println(c%a);
System.out.println( a>b);
System.out.println( a<b);
System.out.println( a==b);
System.out.println( a!=b);
}
}
/*
2
false
true
false
true
*/
8 自增 自减 初识Math类
自增++，自减–
public class Demo01 {
public static void main(String[] args) {
int a = 3 ;
int b = a++ ;
int c = ++a;
System.out.println(a);//5
System.out.println(b);//3 先弹出值 ，再运算、令 啊
System.out.println(c);//5
}
}
幂运算 2^3=Math.pow(2,3);
//幂运算 2^3 2*2*2=8 :
//double pow = Math.pow(2,3);
// (底数，指数)double型System.out.println(pow);
//8.0
public class Demo01 {
public static void main(String[] args) {
double pow = Math.pow(2,3);
System.out.println(pow);
System.out.println(Math.max(575784_32___43L,56));
}
}
//扩展：笔试题 i=5 s=(i++)+(++i)+(i--)+(--i) s=?
//int i=5; int s=(i++)+(++i)+(i--)+(--i); System.out.println(s); //24
9逻辑运算符_位运算符 与或非（短路）：and or 取反
逻辑运算符:
- && 逻辑与运算：两个变量都为真，结果为true
- || 逻辑与运算：两个变量有一个为真，结果为true
- ! 取反，真变为假，假变为真
public class Demo01 {
public static void main(String[] args) {
//与(and)或(or)非（取反）
boolean a = true;
boolean b = false;
System.out.println(a && b); //false
System.out.println(a || b); //true
System.out.println(a && b); //true
//&&短路运算 ：第一个值为false，后面就不进行判定了
System.out.println("++++++++++");
int c = 5;
boolean d = (c < 5) && (c++ < 5);
//第一个值为false，后面就不进行判定了
System.out.println(d); //false
System.out.println(c); //5 c++未执行
//｜｜短路运算 第一个值为true，后面就不进行判定了
System.out.println("++++++++++");
int e= 7;
boolean f= (e<8)||(e--<7);
System.out.println(f);
System.out.println(e);
}
}
位运算
<<左移 *2 效率极高！！
>>右移 /2
/*
A = 0011 1100
B = 0000 1101
A&B 0000 1101 按位与 都1 才1
A|B 0011 1101 按位或 都0 才0
A^B 0011 0001 异或（取反）相同为0，否则为1
~B 1111 0010 非
面试题：2*8 怎么算最快？
0000 0000 //0
0000 0001 //1
0000 0010 //2
0000 0100 //4 2 左移一位变成4
0000 0101 //5
0000 1000 //8
0001 0000 //16
2<<3 //16
2*2*2*2
<<左移 *2 效率极高！！
>>右移 /2
*/
System.out.println(2<<3); // 16
10 三元运算符 += -= ? :
+= -=
public class Demo01 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a);
a += b; //a = a+b; a+b之后再把结果赋值给a
System.out.println(a);
a -= b; //a = a+b; a+b之后再把结果赋值给a
System.out.println(a);
//字符串连接符 + ，转化为String类型,然后拼接 注意！
System.out.println(""+a+b); //1020
System.out.println(a+b+""); //30 先进行运算，再转为String拼接
System.out.println(a+b+"str"); //30str
}
}
/*
10
30
10
1020
30
30str
]*/
? :
public class Demo01 {
public static void main(String[] args) {
//x ? y : z //如果x为真，则结果为y，否则为z
//if(x) y; else z;
int score = 80;
String type = score < 60 ? "及格" : "不及格";
System.out.println(type); //及格
int 胸围 = 90;
String 幸福吗 = 胸围 > 80 ? "幸せ～～" : "まあまあ";
System.out.println(幸福吗);
System.out.println("=========");
//布尔值扩展
boolean 面试成功 = false;
String 人生 = 面试成功 ? "留在阿里" : "进入微软";
System.out.println(人生);
}
}
/*
不及格
幸せ～～
=========
进入微软
*/
11包机制
1 包机制基本介绍
- 为了更好地组织类，Java提供了包机制，由于区分类名的命名空间包的语法格式：package pkg1[.pkg2[.pkg3…]];
- 一般利用公司域名倒置作为包名；com.zhangyy.www
- 点击齿轮，找到Compact开头的选项取消勾选
- 为了能够使用一个包的成员，需要在Java程序中导入该包
import package1[.package2…].(className| ); //通配符 导入包下所有的类
下面示例：
- 定义一个类，在主方法中，
- 进行类的实例化，
- 获取类的实例变量name的值，并储存在 字符串类型的 meName中，
- 打印出来。
- 进行实例方法对本类的调用
// 在com.zhangyy.base0802包中定义一个名为HelloWorld0802的类 就是本文件路径
package com.zhangyy.base0802;
// 定义HelloWorld0802类
public class HelloWorld0802 {
// 定义一个字符串类型的公共实例变量name并初始化为"我是080002"
public String name = "我是080002";
// 定义一个静态变量age并初始化为80
static int age = 80;
// 主方法，程序入口
public static void main(String[] args) {
// 打印输出字符串"hello world 0802"
System.out.println("hello world 0802");
// 创建HelloWorld0802类的实例me
HelloWorld0802 me = new HelloWorld0802();
// 从实例me中获取实例变量name的值并存储在meName中
String meName = me.name;
// 打印输出meName的值
System.out.println(meName);
// 调用实例方法run
me.run();
}
// 定义一个公共方法run
public void run() {
// 打印输出字符串"0802runing..."
System.out.println("0802runing...");
}
}
然后，下面示例 如何在其他的类中，导入HelloWorld0802公共类，并进行实例化，调用类中的实例变量和实例方法。
// 在com.zhangyy.operator包中定义一个名为Demo01的类
package com.zhangyy.operator;
// 导入com.zhangyy.base0802包中的HelloWorld0802类
import com.zhangyy.base0802.HelloWorld0802;
// 定义Demo01类
public class Demo01 {
// 主方法，程序入口
public static void main(String[] args) {
// 创建HelloWorld0802类的实例helloWorld0806
HelloWorld0802 helloWorld0806 = new HelloWorld0802();
// 打印输出helloWorld0806的实例变量name的值
System.out.println(helloWorld0806.name);
// 调用helloWorld0806的实例方法run
helloWorld0806.run();
}
}
·老母猪戴凶罩：如何在一个类中，直接调用另一个类的主方法呢？
如上，如何在类Demo01中调用 另一个类 HelloWorld0802 的main方法呢？
在Java中，从一个类调用另一个类的main方法并不是一种常见或推荐的做法，
因为main方法通常是程序的入口点，而应该在启动应用程序时由JVM自动调用。然而，如果真的需要在一个类中调用另一个类的main方法，可以使用以下步骤：
- 在HelloWorld0802类中，将main方法中的逻辑抽取到一个新的非静态方法中，这样可以在其他类中调用。
- 在Demo01类中，创建一个HelloWorld0802的实例，然后调用第一步中抽取出的方法。
- 一个示例：
在 HelloWorld0802 类中：
package com.zhangyy.base0802;
public class HelloWorld0802 {
public String name = "我是080002";
static int age = 80;
// 抽取逻辑到非静态方法
public void doSomething() {
System.out.println("hello world 0802");
String meName = this.name;
System.out.println(meName);
this.run();
}
public void run() {
System.out.println("0802runing...");
}
public static void main(String[] args) {
HelloWorld0802 me = new HelloWorld0802();
me.doSomething(); // 调用抽取出的方法
}
}
在 Demo01 类中：
package com.zhangyy.operator;
import com.zhangyy.base0802.HelloWorld0802;
public class Demo01 {
public static void main(String[] args) {
HelloWorld0802 helloWorld0806 = new HelloWorld0802();
helloWorld0806.doSomething(); // 调用抽取出的方法
}
}
注意，这种方法并不常见，通常不会在一个类的main方法中放入需要在其他类中调用的逻辑。相反，可以将共享的逻辑封装成一个方法，并在需要的地方调用。如下：
- 当在Java中需要在一个类中调用另一个类的方法，特别是main方法时，通常会遵循以下步骤：
- 抽取共享逻辑：将需要在多个地方重复使用的逻辑抽取到一个单独的方法中，这样可以在多个类中调用这个方法，避免重复代码。
- 调用方法：在需要的类中创建另一个类的实例，并调用之前抽取的方法。
- 详细解释这个过程，使用之前提到的 HelloWorld0802 类和 Demo01 类的示例：
在 HelloWorld0802 类中，抽取了之前在 main 方法中的逻辑
到一个名为 doSomething() 的非静态方法：
public class HelloWorld0802 {
public String name = "我是080002";
// 抽取逻辑到非静态方法
public void doSomething() {
System.out.println("hello world 0802");
String meName = this.name;
System.out.println(meName);
this.run();
}
public void run() {
System.out.println("0802runing...");
}
public static void main(String[] args) {
HelloWorld0802 me = new HelloWorld0802();
me.doSomething(); // 调用抽取出的方法
}
}
· 抽取逻辑到非静态方法 ：这里，我们插播一下。精妙。
当在Java中需要在一个类中调用另一个类的方法，特别是main方法时，通常会遵循以下步骤：
- 抽取共享逻辑：将需要在多个地方重复使用的逻辑抽取到一个单独的方法中，这样可以在多个类中调用这个方法，避免重复代码。
- 调用方法：在需要的类中创建另一个类的实例，并调用之前抽取的方法。
- 细解释这个过程，使用之前提到的 HelloWorld0802 类和 Demo01 类的示例：
在 HelloWorld0802 类中，抽取了之前在 main 方法中的逻辑到一个名为 doSomething() 的非静态方法：
public class HelloWorld0802 {
public String name = "我是080002";
// 抽取逻辑到非静态方法 ：这里，我们插播一下。精妙。
public void doSomething() {
System.out.println("hello world 0802");
String meName = this.name;
System.out.println(meName);
this.run();
}
public void run() {
System.out.println("0802runing...");
}
public static void main(String[] args) {
HelloWorld0802 me = new HelloWorld0802();
//直接在主法中进行实例化，
//就地进行实例化方法的调用 咬住自己的尾巴
me.doSomething(); // 调用抽取出的方法
}
}
/*
hello world 08022222
我是080002
0802runing...
*/
在 Demo01 类中，创建了 HelloWorld0802 的实例，并调用了它的 doSomething() 方法：
package com.zhangyy.operator;
import com.zhangyy.base0802.HelloWorld0802;
public class Demo01 {
public static void main(String[] args) {
System.out.println("i am Demo01 です ");
HelloWorld0802 helloWorld0806 = new HelloWorld0802();
helloWorld0806.doSomething(); // 调用抽取出的方法
}
}
/*
i am Demo01 です
hello world 08022222
我是080002
0802runing...
*/
真是老母猪戴凶罩，一套又一套。
思想：把main方法做成活口，然后：这里我们插播一下。
套中套，就是在一个程序中，运行另一个程序。傀儡程序。
实现方式是，类HelloWorld02 金蝉脱壳（打不过就跑），把主方法中的东西，直接献出来了：Demo02你都拿去。
通过这种方式，在 Demo01 类中成功调用了 HelloWorld0802 类中的方法，实现了代码的重用和结构的清晰性。这种做法有助于将代码模块化，并降低代码重复的风险。
记住，通常来说，main 方法应该作为程序的入口点，而不是为了在其他类中调用。如果目标是重用逻辑，将逻辑抽取到非静态方法中，并在需要的地方调用这些方法会更合适。
2 参考：阿里巴巴Java开发手册
JavaDoc生成文档
javadoc命令是用来生成自己API文档的
参数信息
加在类上就是类的注释 加在方法上就是方法的注释
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RUNONQaL-1691320918894)(media/16912011902532/16913198504979.jpg)]
/**
- @author iehmltym
- @create 2023-08-06 19:40
*/
@author 作者名
@version 版本号
@since 指明最早用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
API文档：https://docs.oracle.com/javase/8/docs/api/
3 mac如何使用 idea生成javadoc文档
1、注释、标识符、关键字
2、数据类型
3、类型转换
4、变量、常量
5、运算符
6、包机制、JavaDoc
a-zA-Z ↩︎