Java-初级 01
资料来源于各类论坛
Java 复习篇 1
1.基础篇
1.Jvave开发环境
Java应用程序通常被编译为可在任何Java虚拟机（JVM）上运行的字节码
Jdk->Java开发工具包 jre 运行环境 Jvm java虚拟机->转换字节码文件->本地机器码
2.基本数据类型
1.内置
byte -short-int-long float-double boolean char
2.引用
类似CPP的指针->指向了存储的真实地址 -对象 数组
ps:
1.常量-final -指定后无法更改
2.类型转换-大转小-精度丢失--强制转 小转大-自动
3.Jave变量类型
- 类变量：独立于方法之外的变量，用 static 修饰。-静态存储区-
- 示例变量：独立于方法之外的变量，不过没有 static 修饰。
- 局部变量：类的方法中的变量。--堆栈中开辟
什么时候销毁-
4.Java运算符
-
算术运算符
+ - * / ％ ++ -- -
关系运算符
== != > < >= <= -
位运算符
＆ 如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100 | 如果相对应位都是 0，则结果为 0，否则为 1 （A | B）得到61，即 0011 1101 ^ 如果相对应位值相同，则结果为0，否则为1 （A ^ B）得到49，即 0011 0001 〜 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011 << 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000 >> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111 >>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111 -
逻辑运算符
&& | | ！ -
赋值运算符
-
省
-
其他运算符
1.三元运算符
-
variable x = (expression) ? value if true : value if false
2.类型比对
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
5.Java输入和输出
System.out.println();
//创建Scanner对象
Scanner input = new Scanner(System.in);
//接受用户的输入
int number = input.nextInt();
6.Java 表达式 语句 代码块
7.Java注释
8. 逻辑控制语句
if -switch
ps-
int week = 4;
String day;
switch (week) {
case 1:
day = "Sunday";
break;
default:
day = "Invalid day";
break;
}
9.循环语句
for -for -each -while
for -each
for (char item: vowels) {
System.out.println(item);
}
//内置迭代器写法
break-跳出循环语句
也就是直接跳出jmp--走到下行代码地址
continue-当前循环跳过语句
10.数组
1.数组
数组是相似类型数据的集合。它是一个容器，用于保存单一类型的数据（值）。例如，您可以创建一个数组，它可以保存100个int类型的值。
data = new Double[10];
2.多维数组
3.数组复制
省
2.面向对象篇
1.Java类和对象
类--一个抽象的东西--由一些数据类型组成的抽象东西
对象--实例化后在内存中(栈)中开辟的一块空间
2.方法
modifier static returnType nameOfMethod (parameters) {
// method body
}
方法到底是什么--方法也是抽象的-也只有在程序运行时 转换为字节码文件
call-oxxxxx->这个地址内就存储着我们方法代码转换的字节码文件
3.构造函数
当类的对象被创建时，该构造函数将被自动调用-并且不返回任何值
4.修饰符
- 访问修饰符
- 非访问修饰符 static final abstract synchronized -无需锁 transient volatile -无需锁
- abstract-抽象类和抽象方法定义
5.字符串
String type = "java programming"; 该字符串是String类的实例。--指向了字符串的地址
| concat() | 将两个字符串连接在一起 |
|---|---|
| equals() | 比较两个字符串的值 |
| charAt() | 返回存在于指定位置的字符 |
| getBytes() | 将字符串转换为字节数组 |
| indexOf() | 返回字符串中指定字符的位置 |
| length() | 返回指定字符串的大小 |
| replace() | 将指定的旧字符替换为指定的新字符 |
| substring() | 返回字符串的子字符串 |
| split() | 将字符串分成字符串数组 |
| toLowerCase() | 将字符串转换为小写 |
| toUpperCase() | 将字符串转换为大写 |
| valueOf() | 返回指定数据的字符串表示形式 |
6.this关键字
在Java中，this关键字用于引用方法或构造函数中的当前对象
--this->指向当前对象地址的一个引用-指针
7.final关键字
在Java中，final关键字用于表示常量。它可以与变量，方法和类一起使用。
任何实体（变量，方法或类）一旦被声明final后，只能分配一次。也就是，
- final变量不能用另一个值重新初始化
- final方法不能被重写
- final类不能被继承
8.instanceof关键字
在Java中，instanceof关键字是二进制运算符。它用于检查对象是否是特定类的实例。
9.递归
在Java中，调用自身的方法称为递归方法。并且，此过程称为递归。
递归优点-简单
缺点--疯狂开堆栈--又疯狂置空
3.面向对象下
1.继承 方法重写 super关键字 抽象类和方法
方法重写--重写覆盖
抽象类是无法实例化的类 abstract-抽象方法
继承抽象类的类 必须实习抽象方法
2.接口
interface-接口声明
-implements -实现实现接口类的方法
接口可以继承其他接口
3.多态-方法重载
同一实体（方法，运算符或对象）在不同情况下的行为会有所不同。
多态在汇编中来看-call-函数
这个call是动态计算的-
这也就是动态绑定
在程序执行期间确定将要调用的方法。因此，方法重写是运行时多态。
方法重载
在Java类中，如果参数不同，则可以使用相同的名称创建方法。
也就是编译器。根据参数判断-对呀call
也就是编译阶段把对应call写进去
在方法重写的情况下，方法应该在不同的类中。然而，在方法重载的情况下，方法应该在同一个类中。
方法重写在运行时执行，而方法重载在编译时执行。
向上 子转父 安全
向下 父转子
看范围把
向上 子转父 安全 指针范围调控
向下 父转子 指针范围扩大。访问到不能访问
4.封装
。封装是指将字段和方法绑定在单个类中。
5.嵌套类
另一个类中定义一个类
6.嵌套静态类
//静态嵌套类的对象创建
Animal.Mammal mammal = new Animal.Mammal();
7.Java 匿名类
class outerClass {
//定义匿名类
object1 = new Type(parameterList) {
//匿名类的主体
};
interface Polygon {
public void display();
}
class AnonymousDemo {
public void createClass() {
//匿名类实现接口
Polygon p1 = new Polygon() {
public void display() {
System.out.println("匿名类的内部。");
}
};
p1.display();
}
}
class Main {
public static void main(String[] args) {
AnonymousDemo an = new AnonymousDemo();
an.createClass();
}
}
一个类可以包含另一个称为嵌套类的类。可以在不提供任何名称的情况下创建嵌套类。
没有任何名称的嵌套类称为匿名类。
必须在另一个类中定义一个匿名类。因此，它也被称为匿名内部类
8.单例模式
它确保只创建一个类的实例。
设计模式就像我们的代码库一样，其中包含世界各地程序员共享的各种编码技术。
class Database {
private static Database dbObject;
private Database() {
}
public static Database getInstance() {
//创建对象（如果尚未创建）
if(dbObject == null) {
dbObject = new Database();
}
//返回单例对象
return dbObject;
}
public void getConnection() {
System.out.println("现在已经连接到数据库。");
}
}
class Main {
public static void main(String[] args) {
Database db1;
//引用Database的唯一对象
db1= Database.getInstance();
db1.getConnection();
}
}
单例模式
确保只有一个实例化的对象
也就是需要静态方法 返回已经实例好的对象
返回的对象就可以调用该调用的了
9.枚举
enum Size {
SMALL, MEDIUM, LARGE, EXTRALARGE
}
class Size {
public final static int SMALL = 1;
public final static int MEDIUM = 2;
public final static int LARGE = 3;
public final static int EXTRALARGE = 4;
}
代码多用枚举
10.反射
反射允许我们在运行时检查和操作类、接口、构造函数、方法和字段。
Java中有一个名为Class的类，该类在运行时保留有关对象和类的所有信息。
Class对象描述了特定类的属性。该对象用于执行反射。
class 反射-
Class.forName("Dog");
Dog d1 = new Dog()
Class c1 = d1.getClass();
Class c1 = Dog.class;
1.反射作用
1.获取接口 -
我们可以使用Class的getInterfaces()方法来收集类实现的接口的信息。此方法返回一个接口数组
Class obj = d1.getClass();
//查找由Dog实现的接口
Class[] objInterface = obj.getInterfaces();
for(Class c : objInterface) {
//打印接口名称
System.out.println("Interface Name: " + c.getName());
}
}
2.获取超类和访问修饰符
获取超类和访问修饰符
类Class的方法getSuperclass()可用于获取有关特定类的超类的信息。
而且，Class提供了一种getModifier()方法，该方法以整数形式返回class的修饰符。
//找到Dog的超类
Class superClass = obj.getSuperclass();
System.out.println("Superclass: " + superClass.getName());
}
3.反射字段，方法和构造函数
该软件包java.lang.reflect提供了可用于操作类成员的类。例如，
方法类 - 提供有关类中方法的信息
字段类 - 提供有关类中字段的信息
构造函数类 - 提供有关类中构造函数的信息
Java 反射与字段
我们可以使用Field类提供的各种方法检查和修改类的不同字段。
getFields() - 返回该类及其超类的所有公共字段
getDeclaredFields() - 返回类的所有字段
getModifier() - 以整数形式返回字段的修饰符
set(classObject,value) - 使用指定的值设置字段的值
get(classObject) - 获取字段的值
setAccessible(boolean) - 使私有字段可访问
注意：如果我们知道字段名称，则可以使用
getField("fieldName"） - 从类返回名称为fieldName的公共字段。
getDeclaredField("fieldName"） - 从类返回名称为fieldName的字段。
示例：访问私有字段
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
private String color;
}
class ReflectionDemo {
public static void main(String[] args) {
try {
Dog d1 = new Dog();
//创建类Class对象
Class obj = d1.getClass();
//访问私有字段
Field field2 = obj.getDeclaredField("color");
//使私有字段可访问
field2.setAccessible(true);
//设置color值
field2.set(d1, "brown");
// get the value of type converting in String
String colorValue = (String)field2.get(d1);
System.out.println("color: " + colorValue);
//获取color的访问修饰符
int mod2 = field2.getModifiers();
String modifier2 = Modifier.toString(mod2);
System.out.println("modifier: " + modifier2);
}
catch(Exception e) {
e.printStackTrace();
}
}
}
输出结果
color: brown
modifier: private
5.反射 方法
Java 反射与方法
像字段一样，我们可以使用Method类提供的各种方法来检查类的不同方法。
getMethods() - 返回该类及其超类的所有公共方法
getDeclaredMethod() - 返回该类的所有方法
getName() - 返回方法的名称
getModifiers() - 以整数形式返回方法的访问修饰符
getReturnType() - 返回方法的返回类型
示例：方法反射
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
public void display() {
System.out.println("I am a dog.");
}
protected void eat() {
System.out.println("I eat dog food.");
}
private void makeSound() {
System.out.println("Bark Bark");
}
}
class ReflectionDemo {
public static void main(String[] args) {
try {
Dog d1 = new Dog();
//创建一个Class对象
Class obj = d1.getClass();
//使用getDeclaredMethod()获取所有方法
Method[] methods = obj.getDeclaredMethods();
//获取方法的名称
for(Method m : methods) {
System.out.println("方法名称： " + m.getName());
//获取方法的访问修饰符
int modifier = m.getModifiers();
System.out.println("修饰符： " + Modifier.toString(modifier));
//获取方法的返回类型
System.out.println("Return Types: " + m.getReturnType());
System.out.println(" ");
}
}
catch(Exception e) {
e.printStackTrace();
}
}
}
输出结果
方法名称： display
修饰符： public
Return type: void
方法名称： eat
修饰符： protected
返回类型： void
方法名称： makeSound
修饰符： private
返回类型： void
6.Java 反射与构造函数
我们还可以使用Constructor类提供的各种方法检查类的不同构造函数。
getConstructors() - 返回该类的所有公共构造函数以及该类的超类
getDeclaredConstructor() -返回所有构造函数
getName() - 返回构造函数的名称
getModifiers() - 以整数形式返回构造函数的访问修饰符
getParameterCount() - 返回构造函数的参数数量
示例：构造函数反射
示例：构造函数反射
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
public Dog() {
}
public Dog(int age) {
}
private Dog(String sound, String type) {
}
}
class ReflectionDemo {
public static void main(String[] args) {
try {
Dog d1 = new Dog();
Class obj = d1.getClass();
//使用getDeclaredConstructor()获取一个类中的所有构造函数
Constructor[] constructors = obj.getDeclaredConstructors();
for(Constructor c : constructors) {
//获取构造函数的名称
System.out.println("构造函数名称： " + c.getName());
//获取构造函数的访问修饰符
int modifier = c.getModifiers();
System.out.println("修饰符： " + Modifier.toString(modifier));
//获取构造函数中的参数数量
System.out.println("参数个数： " + c.getParameterCount());
}
}
catch(Exception e) {
e.printStackTrace();
}
}
}
输出结果
构造函数名称： Dog
修饰符： public
参数个数： 0
构造函数名称： Dog
修饰符： public
参数个数： 1
构造函数名称： Dog
修饰符： private
参数个数： 2
11.包
package pkg1[．pkg2[．pkg3…]];
那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
也就是命名空间 这样变量可以重名
以下是一些 Java 中的包：
java.lang-打包基础的类
java.io-包含输入输出功能的函数
开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。
由于包创建了新的命名空间(namespace)，所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。
import 关键字
为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。
3.异常处理
1.异常认识
Throwable-根类
Error
Error表示不可恢复的情况，例如Java虚拟机（JVM）内存不足，内存泄漏，堆栈溢出错误，库不兼容，无限递归等
Exception
程序可以捕获并处理异常。
当方法内发生异常时，它将创建一个对象。该对象称为异常对象。
它包含有关异常的信息，例如异常的名称和说明以及发生异常时的程序状态。
2.异常处理
try {
// 代码
} catch (ExceptionType e) {
// 捕获块
} finally {
//finally块
}
3.异常抛出
1.异常层层抛出 throws
accessModifier returnType methodName() throws ExceptionType1, ExceptionType2 … {
// code
}
import java.io.*;
class Main {
public static void findFile() throws IOException {
//可能产生IOException的代码
File newFile=new File("test.txt");
FileInputStream stream=new FileInputStream(newFile);
}
public static void main(String[] args) {
try{
findFile();//内部异常抛出 MAIN捕获
} catch(IOException e){
System.out.println(e);
}
}
}
2.自动抛出异常
throw throwableObject;
class Main {
public static void divideByZero() {
throw new ArithmeticException("试图除以0");
}
public static void main(String[] args) {
divideByZero();
}
}
import java.io.*;
class Main {
public static void findFile() throws IOException {
throw new IOException("文件未找到");
}
public static void main(String[] args) {
try {
findFile();
System.out.println("try块中的其余代码");
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
3.try with resources
--释放资源还是自己操作-- 省
try(new的东西)-当有异常自动给你释放掉
4.注解
---Java注解是我们程序源代码的元数据（有关数据的数据）。
它们向编译器提供关于程序的附加信息，但不是程序本身的一部分
@AnnotationName
@AnnotationName(elementName = "elementValue")
@AnnotationName(element1 = "value1", element2 = "value2")
List<@NonNull String> newList;
该声明指定String类型的非空值的列表。
5.日志-Logging-省
Java允许我们通过日志记录过程来创建和捕获日志消息和文件。
在Java中，日志记录需要框架和API。Java在java.util.logging程序包中具有内置的日志记录框架。
我们还可以将第三方框架（如Log4j，Logback等）用于日志记录。
6.断言
Java中的断言通过测试我们认为是正确的代码来帮助检测错误。
使用assert关键字进行断言
-默认关闭需要启用-
启用断言且条件为时true，程序将正常执行。
但是，如果在启用断言时条件计算为false, JVM会抛出AssertionError，程序会立即停止。
class Main {
public static void main(String args[]) {
String[] weekends = {"Friday", "Saturday", "Sunday"};
assert weekends.length==2 : "There are only 2 weekends in a week";
System.out.println("There are " + weekends.length + " weekends in a week");
}
}
总结
匿名 -反射-
本文来自博客园，作者：逆向狗，转载请注明原文链接：https://www.cnblogs.com/Agtw/p/18084095
【推荐】还在用 ECharts 开发大屏？试试这款永久免费的开源 BI 工具！
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步