一、java的优势是什么？
- Java简单易用，Java语言的简单是相较于C语言来说的，因为Java语言脱胎于C语言，但比C语言更容易学，而且用Java编程也更简洁，大大提高了编程的效率，这就使得越来越多的人用Java来编写程序。
- Java语言是面向对象的编程语言，在现实生活中我们每时每刻都在与对象打交道，因此Java更符合人们的思维模式，使人们更容易编写程序，也更容易学习。
- Java语言安全性高，用Java语言编写的程序不容易被病毒入侵，而且Java不支持指针，一切对内存的访问都必须通过对象的实例变量来实现，所以Java也不容易被木马入侵。
- Java语言具有优秀的跨平台能力，因为Java的平台无关性使得用Java编写的程序可以在任何安装了Java虚拟机JVM的计算机上正确的运行，而其他语言却不能做到这一点。
- Java具有动态性，Java的类既可以自己编写也可以从类库中引入，而且类是可以运行时动态装载，这对于 Java编写的软件说升级很方便。
java初识：
public class text6 {
static String s1 = "你好ya "; //成员变量
//public权限修饰符、static静态修饰符、void返回值修饰符、main主方法、String[] args主方法的参数
public static void main(String[] args) {
String s2 = "你好"; //成员变量
System.out.println(s1);
System.out.println(s2);
}
}程序开发人员不可或缺的工具：
API文档下载：api
二、java------>基本数据类型
Java 的基本数据类型包括以下几种：
整数类型：
- byte：8 位，范围为 -128 到 127
- short：16 位，范围为 -32768 到 32767
- int：32 位，范围为 -2147483648 到 2147483647
- long：64 位，范围为 -9223372036854775808 到 9223372036854775807
byte myByte = 10; short myShort = 1000; int myInt = 100000; long myLong = 10000000000L; // 注意：在赋值时，long 类型的值需要加上 "L" 或 "l"浮点类型：
- float：32 位，单精度浮点数
- double：64 位，双精度浮点数
float myFloat = 3.14f; // 注意：在赋值时，float 类型的值需要加上 "F" 或 "f" double myDouble = 3.14;字符类型：
- char：16 位 Unicode 字符
char myChar = 'A'; //单引号，单字符 String myString = "hello world"; //字符串不属于基本数据类型布尔类型：
- boolean：表示 true 或 false
boolean myBoolean = true;
字符与Unicode码的转换：
public class CharUnicodeExample { public static void main(String[] args) { // 字符到Unicode码的转换 char myChar = 'A'; int unicodeValue = (int) myChar; System.out.println("Character: " + myChar); System.out.println("Unicode Value: " + unicodeValue); // Unicode码到字符的转换 int unicodeValue2 = 66; char myChar2 = (char) unicodeValue2; System.out.println("Unicode Value: " + unicodeValue2); System.out.println("Character: " + myChar2); } }
三、标识符和关键字
标识符（Identifier）：
标识符是程序员定义的名称，用于标识变量、方法、类等程序实体。标识符必须符合一定的命名规则，以字母（A-Z，a-z）、下划线（_）或美元符号（$）开头，后面可以跟字母、数字（0-9）或美元符号（$）开头，后面可以跟字母、数字（0-9）、下划线（）或美元符号（$）。Java是大小写敏感的，因此大写字母和小写字母被视为不同的标识符。
关键字（Keyword）：
关键字是在编程语言中预定义的具有特殊用途的标识符。这些关键字有着固定的含义，不能被用作标识符。在Java中，有一组保留的关键字，如class、public、'静态static、'voidvoid等。
下面是一个简单的Java代码示例，展示了标识符和关键字的用法：
public class Example {
// 标识符示例：变量名
int myVariable = 42;
// 标识符示例：方法名
void myMethod() {
System.out.println("Hello from myMethod!");
}
public static void main(String[] args) {
// 关键字示例：class、public、static、void
IdentifierAndKeywordExample example = new IdentifierAndKeywordExample();
example.myMethod();
}
}
四、变量
声明、初始化和使用变量：
public class VariableExample {
public static void main(String[] args) {
// 声明变量
int myNumber;
double myDouble;
String myString;
// 初始化变量
myNumber = 10;
myDouble = 3.14;
myString = "Hello, Java!";
// 在声明的同时初始化变量
int anotherNumber = 20;
// 输出变量值
System.out.println("myNumber: " + myNumber);
System.out.println("myDouble: " + myDouble);
System.out.println("myString: " + myString);
System.out.println("anotherNumber: " + anotherNumber);
// 修改变量值
myNumber = 42;
myDouble = 2.718;
myString = "Java is fun!";
// 输出修改后的变量值
System.out.println("myNumber: " + myNumber);
System.out.println("myDouble: " + myDouble);
System.out.println("myString: " + myString);
}
}
实例变量、静态变量和局部变量说明：
public class VariableExample {
// 实例变量
int instanceVariable1;
double instanceVariable2;
// 静态变量
static String staticVariable = "I am a static variable";
public static void main(String[] args) {
// 局部变量
int localVariable1 = 10;
double localVariable2 = 3.14;
// 创建类的实例
VariableExample instance1 = new VariableExample();
VariableExample instance2 = new VariableExample();
// 访问实例变量
instance1.instanceVariable1 = 20;
instance1.instanceVariable2 = 6.28;
instance2.instanceVariable1 = 30;
instance2.instanceVariable2 = 9.42;
// 访问静态变量
System.out.println("Static Variable: " + staticVariable);
// 访问局部变量
System.out.println("Local Variable 1: " + localVariable1);
System.out.println("Local Variable 2: " + localVariable2);
// 访问实例变量
System.out.println("Instance 1 - Variable 1: " + instance1.instanceVariable1);
System.out.println("Instance 1 - Variable 2: " + instance1.instanceVariable2);
System.out.println("Instance 2 - Variable 1: " + instance2.instanceVariable1);
System.out.println("Instance 2 - Variable 2: " + instance2.instanceVariable2);
}
}
实例变量、静态变量和局部变量具有不同的作用域：
实例变量（Instance Variable）的作用域：
- 实例变量属于类的实例（对象）。
- 作用域限定在对象内部，每个对象都有一份实例变量的拷贝。
- 实例变量在整个对象的生命周期内有效，可以通过对象引用访问。
public class MyClass { int instanceVariable; // 实例变量 public static void main(String[] args) { MyClass obj1 = new MyClass(); obj1.instanceVariable = 10; // 可以通过对象引用访问实例变量 MyClass obj2 = new MyClass(); obj2.instanceVariable = 20; } }
静态变量（Static Variable）的作用域：
- 静态变量属于类，而不是类的实例。
- 作用域在整个类的生命周期内，所有类的实例共享同一份静态变量。
- 可以通过类名直接访问静态变量。
public class MyClass { static int staticVariable; // 静态变量 public static void main(String[] args) { MyClass.staticVariable = 100; // 可以通过类名访问静态变量 } }
局部变量（Local Variable）的作用域：
- 局部变量在方法、代码块或构造方法中声明。
- 作用域仅限于声明的方法、代码块或构造方法内部。
- 生命周期在方法、代码块或构造方法的执行期间。
public class MyClass { public static void main(String[] args) { int localVar1 = 5; // 局部变量 if (localVar1 > 0) { int localVar2 = 10; // 局部变量 System.out.println(localVar2); } // System.out.println(localVar2); // 编译错误，局部变量超出作用域 } }
五、运算符
赋值运算符：
“=”赋值int a = 5; int b = a; // 将a的值赋给b算术运算符：
+：加法-：减法*：乘法/：除法%：取模（取余）int a = 10, b = 3; int sum = a + b; // 13 int difference = a - b; // 7 int product = a * b; // 30 int quotient = a / b; // 3 int remainder = a % b; // 1关系运算符：
==：等于!=：不等于>：大于<：小于>=：大于等于<=：小于等于int x = 5, y = 10; boolean isEqual = (x == y); // false boolean isNotEqual = (x != y); // true boolean isGreaterThan = (x > y); // false boolean isLessThan = (x < y); // true逻辑运算符：
&&：逻辑与（AND）||：逻辑或（OR）!：逻辑非（NOT）boolean condition1 = true, condition2 = false; boolean resultAnd = condition1 && condition2; // false boolean resultOr = condition1 || condition2; // true boolean resultNot = !condition1; // false位运算符：
位运算符用于在二进制位级别上操作整数类型的数据
&：按位与|：按位或^：按位异或~：按位取反<<：左移位>>：右移位>>>：无符号右移位int num1 = 5, num2 = 3; int bitwiseAnd = num1 & num2; // 1 int bitwiseOr = num1 | num2; // 7 int bitwiseXor = num1 ^ num2; // 6 int bitwiseNot = ~num1; // -6 int leftShift = num1 << 1; // 10 int rightShift = num1 >> 1; // 2 int unsignedRightShift = num1 >>> 1; // 2 /* 按位与（&）： 对两个二进制数的每一位执行与操作，如果对应位都是1，则结果为1；否则为0。 按位或（|）： 对两个二进制数的每一位执行或操作，如果对应位有一个为1，则结果为1；否则为0。 按位异或（^）： 对两个二进制数的每一位执行异或操作，如果对应位不同，则结果为1；否则为0。 按位取反（~）： 对二进制数的每一位执行取反操作，即将0变为1，将1变为0。 左移位（<<）： 将一个二进制数的所有位向左移动指定的位数，右侧空出的位用0填充。 右移位（>>）： 将一个二进制数的所有位向右移动指定的位数，左侧空出的位用原来的最高位填充。对于正数，左侧补0；对于负数，左侧补1。 无符号右移位（>>>）： 类似右移位，但是左侧空出的位总是用0填充，不考虑正负号。 */
六、数据类型转换
1. 隐式类型转换（自动类型转换）：
隐式类型转换是由编译器自动完成的，不需要程序员明确地进行操作。它发生在数据类型范围小的变量赋值给数据类型范围大的变量时。例如，将一个
int类型的值赋给long类型的变量。int intValue = 42; long longValue = intValue; // 隐式类型转换，int转换为long2. 显式类型转换（强制类型转换）：
显式类型转换需要程序员明确地进行，通常发生在数据类型范围大的变量赋值给数据类型范围小的变量时。因为这种转换可能导致数据溢出或精度损失，所以需要程序员的手动干预。
double doubleValue = 3.14; int intValue = (int) doubleValue; // 显式类型转换，double转换为int注意事项：
- 在进行类型转换时，可能会导致数据丢失或溢出，因此需要谨慎使用。
- 转换时应确保目标类型能够容纳源类型的值，否则可能会导致编译错误或运行时异常。
七、代码注释
单行注释：
单行注释以
//开头，用于注释掉一行代码或在一行代码后添加说明。多行注释：
多行注释以
/*开头，以*/结尾，可以跨足多行，用于注释掉一块代码或添加详细的说明。文档注释：
public class Example { // 单行注释，用于声明整数变量 int number = 42; /* 这是一个多行注释示例 用于注释掉一块代码 */ // int anotherNumber = 10; // 这行代码被注释掉了 /** * 这是一个文档注释示例 * 用于生成代码文档，包含对方法的详细说明 * @param x 参数x * @param y 参数y * @return 返回值 */ public int add(int x, int y) { return x + y; } }
八、流程控制
主要的流程控制结构包括条件语句（if-else语句）、循环语句（for循环、while循环、do-while循环）、分支语句（switch语句）等。
1. 条件语句：
1.1 if-else语句：
if (condition) { // 如果条件为真，执行这里的代码 } else { // 如果条件为假，执行这里的代码 }1.2 if-else if-
if (condition1) { // 如果条件1为真，执行这里的代码 } else if (condition2) { // 如果条件2为真，执行这里的代码 } else { // 如果前面的条件都为假，执行这里的代码 }
2. 循环语句：
2.1 for循环：
for (int i = 0; i < 5; i++) { // 循环体，执行5次 }2.2 while循环：
while (condition) { // 循环体，只要条件为真就一直执行 }2.3 do-while循环：
do { // 循环体，至少执行一次 } while (condition);2.4 foreach循环
int[] numbers = {1, 2, 3, 4, 5}; for (int num : numbers) { System.out.println(num); }
3. 分支语句：
3.1 switch语句：
数据类型：
switch语句支持的数据类型包括整数（byte、short、int）、字符（char）、枚举（enum）和字符串（从Java 7开始）。case 常量：
case后面的常量必须是编译时常量（final变量或字面量），不能是变量。穿透性：
- 在
switch语句中，如果没有在每个case的末尾使用break语句，它会发生“穿透”，即会继续执行下一个case的代码，直到遇到break或者switch语句结束。int day = 3; switch (day) { case 1: // 执行代码 break; case 2: // 执行代码 break; // ... default: // 如果没有匹配的case，执行默认代码 }
4. 跳转语句：
4.1 break语句：
用于跳出循环或switch语句。
for (int i = 0; i < 5; i++) { if (i == 3) { break; // 当 i 等于 3 时，跳出循环 } }4.2 continue语句：
用于终止当前循环的迭代，然后继续下一次迭代。
for (int i = 0; i < 5; i++) { if (i == 2) { continue; // 当 i 等于 2 时，跳过当前迭代，继续下一次迭代 } // 执行其他代码 }
九、数组
数组是一种用于存储相同类型数据元素的数据结构。数组具有固定的大小，一旦创建，其大小不能更改。
1. 声明和创建数组：
// 声明一个整数数组
int[] intArray;
// 创建一个大小为5的整数数组
intArray = new int[5];
// 声明并创建整数数组的简化方式
int[] anotherIntArray = new int[5];
// 直接初始化数组
int[] initializedArray = {1, 2, 3, 4, 5};
2. 访问数组元素：
intArray[0] = 10; // 设置数组第一个元素的值为10
int value = intArray[1]; // 获取数组第二个元素的值
3. 获取数组长度：
int length = intArray.length;
4. 遍历数组：
for (int i = 0; i < intArray.length; i++) {
System.out.println(intArray[i]);
}
//增强版for循环
for (int num : intArray) {
System.out.println(num);
}
5. 多维数组：
// 二维数组
int[][] twoDArray = new int[3][4];
// 初始化二维数组
int[][] initializedTwoDArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
// 访问二维数组元素
int value = twoDArray[1][2];
6. 数组的拷贝：
// 使用 Arrays 类的 copyOf 方法拷贝数组
int[] copiedArray = Arrays.copyOf(intArray, intArray.length);
// 使用 System 类的 arraycopy 方法拷贝数组
int[] copiedArray2 = new int[intArray.length];
System.arraycopy(intArray, 0, copiedArray2, 0, intArray.length);
7. 数组的排序：
// 使用 Arrays 类的 sort 方法对数组进行排序
Arrays.sort(intArray);
8. 数组的搜索：
// 使用 Arrays 类的 binarySearch 方法在有序数组中搜索元素
int index = Arrays.binarySearch(intArray, 5);
十、面向对象
1. 类和对象：
类（Class）：
类是一种用户定义的数据类型，用于表示一类对象的共同属性和行为。它是对象的模板或蓝图。
public class Dog { String name; int age; void bark() { System.out.println("Woof!"); } }对象（Object）：
对象是类的实例，是具体的数据。在上面的例子中，
Dog类可以实例化为多个狗对象。Dog myDog = new Dog();
2. 封装（Encapsulation）：
封装是将对象的状态和行为包装在一起的概念。通过使用访问修饰符（
private、public、protected等），可以限制对对象内部数据的直接访问，使得对象的状态只能通过对象的方法进行操作。public class Dog { private String name; public void setName(String newName) { // 进行一些验证或逻辑处理 this.name = newName; } public String getName() { return this.name; } }
3. 继承（Inheritance）：
继承是通过现有类创建新类的机制。新创建的类称为子类，已存在的类称为父类。子类继承了父类的属性和方法，并可以在此基础上进行扩展或重写。
public class Puppy extends Dog { public void play() { System.out.println("The puppy is playing."); } }
4. 多态（Polymorphism）：
多态允许使用一个父类类型的引用来引用子类对象。在运行时，系统会根据实际对象的类型调用相应的方法。多态包括方法重载和方法重写。
public class Animal { public void makeSound() { System.out.println("Some generic sound"); } } public class Dog extends Animal { public void makeSound() { System.out.println("Woof!"); } } Animal myDog = new Dog(); myDog.makeSound(); // 调用的是 Dog 类中的 makeSound 方法
5. 抽象类和接口：
抽象类（Abstract Class）： 抽象类不能被实例化，用于定义具体类的通用特性，可以包含抽象方法和具体方法。
public abstract class Shape { public abstract void draw(); public void display() { System.out.println("Displaying shape"); } }
十一、巩固抽象和接口
抽象类和接口是面向对象编程中的两个关键概念，它们提供了对类和对象的抽象和规范。
1. 抽象类（Abstract Class）：
1.1 定义抽象类：
抽象类不能被实例化，通常用于定义具体类的通用特性，可以包含抽象方法和具体方法。
public abstract class Shape { protected int x; protected int y; public Shape(int x, int y) { this.x = x; this.y = y; } public abstract void draw(); // 抽象方法 public void move(int newX, int newY) { this.x = newX; this.y = newY; } }1.2 使用抽象类：
public class Circle extends Shape { private int radius; public Circle(int x, int y, int radius) { super(x, y); this.radius = radius; } @Override public void draw() { System.out.println("Drawing a circle at (" + x + ", " + y + ") with radius " + radius); } }1.3 抽象类的应用场景：
- 当多个类有相似的行为或属性时，可以将这些公共的特性提取到一个抽象类中，减少重复代码。
- 抽象类可以包含抽象方法，要求子类必须实现这些方法，提供一种规范。
2. 接口（Interface）：
2.1 定义接口：
接口定义了一组方法，任何实现该接口的类都需要提供这些方法的具体实现。
public interface Drawable { void draw(); // 抽象方法 default void display() { System.out.println("Displaying drawable"); } }2.2 使用接口：
public class Circle implements Drawable { private int x; private int y; private int radius; public Circle(int x, int y, int radius) { this.x = x; this.y = y; this.radius = radius; } @Override public void draw() { System.out.println("Drawing a circle at (" + x + ", " + y + ") with radius " + radius); } }2.3 接口的应用场景：
- 一个类可以实现多个接口，提供了多继承的一种实现方式。
- 接口可以用于定义规范，使得不同的类能够实现相同的行为。
3. 抽象类 vs 接口：
3.1 共同点：
- 都可以包含抽象方法。
- 都可以包含具体方法（在接口中使用
default关键字，或在抽象类中直接定义）。- 都不能被实例化，需要通过子类来实现。
3.2 区别：
继承关系：
- 一个类只能继承一个抽象类，但可以实现多个接口。
- 抽象类可以有构造方法，而接口不能有构造方法。
成员变量：
- 抽象类可以有实例变量、构造方法（可以被子类调用）、静态方法和静态变量。
- 接口只能包含常量（
static final）和抽象方法。方法实现：
- 接口中的所有方法都是抽象的，而抽象类可以包含抽象方法和具体方法。
在选择使用抽象类还是接口时，要根据具体的需求和设计目标进行考虑。通常情况下，如果需要表示一种 is-a 的关系，使用抽象类；如果需要表示一种 has-a 或者 can-do 的关系，使用接口。在实际设计中，有时也可以同时使用抽象类和接口。
4、补充
"is-a" 关系：
如果一个类需要表示某个实体是另一个实体的一种类型，可以使用抽象类。这意味着子类是父类的一种特殊类型。
例如，假设有一个抽象类
Vehicle，其中包含一些通用的属性和方法，然后有两个具体的子类Car和Motorcycle，它们都是Vehicle的一种特殊类型。
abstract class Vehicle {
// 共享的属性和方法
}
class Car extends Vehicle {
// Car 特有的属性和方法
}
class Motorcycle extends Vehicle {
// Motorcycle 特有的属性和方法
}
在这里，我们可以说 "Car is-a Vehicle" 和 "Motorcycle is-a Vehicle"。
"has-a" 或 "can-do" 关系：
-
如果一个类需要表达某个实体具有某种功能或者包含另一个实体，可以使用接口。这意味着这个类有一个功能或者能够执行某些操作，或者包含另一个类的实例。
-
例如，假设有一个接口
Runnable表示可以运行的实体，然后有一个类Car实现了这个接口，表示汽车是可以运行的。interface Runnable { void run(); } class Car implements Runnable { // Car 的具体实现 @Override public void run() { // 实现汽车的运行逻辑 } }在这里，我们可以说 "Car has-a Runnable behavior"，表示 Car 具有 Runnable 接口的行为。
十二、包（Package）
包（Package）是 Java 中用于组织和管理类的一种机制，它提供了一种将相关的类和接口组织在一起的方式，以防止命名冲突，并提高代码的可维护性。
定义包
// 定义一个名为com.example.myapp的包 package com.example.myapp; // 类的定义 public class MyClass { // 类的成员和方法 }导入包
// 导入com.example.myapp包下的MyClass类 import com.example.myapp.MyClass;包的层次结构
包可以有层次结构，形成一个树状层级：
// com是顶级包 package com; // com.example是com的子包 package com.example; // com.example.myapp是com.example的子包 package com.example.myapp; // 类的定义 public class MyClass { // 类的成员和方法 }
十三、内部类（Inner Class）
内部类是定义在其他类内部的类。它有静态内部类、成员内部类、局部内部类和匿名内部类等不同类型。
静态内部类
public class OuterClass { // 外部类的成员 public static class StaticInnerClass { // 静态内部类的成员 } }成员内部类
public class OuterClass { // 外部类的成员 public class MemberInnerClass { // 成员内部类的成员 } }局部内部类
public class OuterClass { // 外部类的成员 public void someMethod() { // 局部内部类 class LocalInnerClass { // 局部内部类的成员 } } }匿名内部类
public interface MyInterface { void myMethod(); } public class OuterClass { public void useInterface() { MyInterface myInterface = new MyInterface() { @Override public void myMethod() { // 实现接口的匿名内部类 } }; } }内部类的使用有助于提高代码的封装性和组织性，但需要根据具体情况选择合适的内部类类型。
2799
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
