java学习总结

共计 4868 个字符，预计需要花费 13 分钟才能阅读完成。

第一个java程序

public class HelloWord{
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

注释

public class zs {
    // 这是单行注释的示例
    /* 这个也是单行注释的示例 */
​
    /* 
    * 
    * 这是一个多行注释的示例
    */
}

对象和类

// 类（class）
public class demo1 {...}
// 对象（Object）
Car myCar = new Csr();
// 继承（Inheritance）
public class Dog extends Animal{...}
// 封装（Encapsulation）
private String name;
private String getName(){return name;}
// 多态（Polymorphism）
// 方法重载：
public int add(int a, int b){...}
// 和
public double add(double a, double b){...}
// 方法重写
@Override
public void makeSoud(){System.out.println("Meow")}
// 抽象（Abstraction）
// 抽象类
public abstract class Shape { 
    // 抽象方法
    abstract void draw();
}
// 接口
public interface Animal { void drive();}
// 接口（Interface）
public interface Drivable { void drive();}
// 方法（Method）
public void displayInfo(){ System.out.println("Info");}
// 方法重载（Method Overloacling）
public int add(int a, int b){ return a + b;}
public double add(double a, double b){ return a + b;}

基本数据类型

byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
默认值：0
​
short 二进制位数：16
java.lang.Byte
Short.MIN_VALUE=-32768
Short.MAX_VALUE=32767
默认值：0
​
int 二进制位数：32
java.lang.Integer
Integer.MIN_VALUE=-2147483648
Integer.MAX_VALUE=2147483647
默认值：0
​
long 二级制位数：64
java.lang.Long
Long.MIN_VALUE=-9223372036854775808
Long.MAX_VALUE=9223372036854775807
默认值：0L
​
float 二进制位数：32
java.lang.Float
Float.MIN_VALUE=1.4E-45
Float.MAX_VALUE=3.4028235E38
默认值：0.0f
​
double 二进制位数：64
java.lang.Double
Double.MIN_VALUE=4.9E-324
Double.MAX_VALUE=1.7976931348623157E308
默认值：0.0d
​
char 二进制位数：16
java.lang.Character
Character.MIN_VALUE=0
Character.MAX_VALUE=65535
'\u0000'
​
补充：
boolean 默认值：false
引用数据类型（类、接口、数组） 默认值：null
常量用final修饰
final double PI = 3.1415926;

一些特殊的转义字符序列

\n          换行 (0x0a)
\r          回车 (0x0d)
\f          换页符(0x0c)
\b          退格 (0x08)
\0          空字符 (0x0)
\s          空格 (0x20)
\t          制表符
\"          双引号
\'          单引号
\\          反斜杠
\ddd        八进制字符 (ddd) 
\uxxxx      16进制Unicode字符 (xxxx)

类型转换

自动类型转换
规则：
1. 不能对boolean类型进行类型转换。
2. 不能把对象类型转换成不相关类的对象。
3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4. 转换过程中可能导致溢出或损失精度，例如：
int i =128;   
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23;        
(int)-45.89f == -45
​
​
强制类型转换
1. 条件是转换的数据类型必须是兼容的。
2. 格式：(type)value type是要强制类型转换后的数据类型 实例：
int i1 = 123;
byte b = (byte)i1;//强制类型转换为byte
​
​
隐含强制类型转换
1、 整数的默认类型是 int。
2、 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

变量类型

局部变量（Local Variables）：局部变量是在方法、构造函数或块内部声明的变量，执行结束后被销毁，局部变量在声明时需要初始化，否则会导致编译错误。

实例（成员）变量（Instance Variables）：实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值。

静态变量或类变量（Class Variables）：类变量是在类中用 static 关键字修饰的变量，它们属于类而不是实例，静态变量在内存中只有一份拷贝，被所有实例共享，类变量在类加载时被初始化，而且只初始化一次。

参数变量（Parameters）：参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。 ⚡值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。 ⚡引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。

变量命名规则

使用驼峰命名法、小写字母开头： 局部变量、实例变量、静态变量、参数

使用驼峰命名法、大写字母开头： 类名

使用全大写字母，单词之间用下划线分隔： 常量

访问控制修饰符

公有访问修饰符-public 受保护的访问修饰符-protected 默认访问修饰符-不使用任何关键字 私有访问修饰符-private

非访问修饰符

static 修饰符 修饰静态变量和静态方法

final 修饰符 final 修饰符通常和 static 修饰符一起使用来创建类常量

abstract 修饰符 声明抽象类和抽象方法 一个类不能同时被 abstract 和 final 修饰

synchronized 修饰符 声明的方法同一时间只能被一个线程访问 synchronized 修饰符可以应用于四个访问修饰符

transient 修饰符 序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。 该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

volatile 修饰符 在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值 当成员变量发生变化时，会强制线程将变化值回写到共享内存 这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值 一个 volatile 对象引用可能是 null

运算符

位运算符

逻辑运算符

按位赋值运算符（二进制之间的运算）

三元运算符 | 条件运算符（?:）

// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
   b = (a == 1) ? 20 : 30;

instanceof 运算符

用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型） 使用格式如下：

String name = "James";
boolean result = name instanceof String;
 // 由于 name 是 String 类型，所以返回真

循环结构

while循环

while( 布尔表达式 ){
  //循环内容
}

do…while 循环

do…while 循环至少会执行一次

do {
       //代码语句
}while(布尔表达式);

for循环

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

增强 for 循环

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

for(声明语句 : 表达式)
{
   //代码句子
}

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。

continue 关键字

作用：让程序立刻跳转到下一次循环的迭代。

条件语句

语法1：

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

语法2：

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

语法3：

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

switch case 语句

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

Number & Math 类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

Math 类是 Java 提供的数学工具类，位于 java.lang 包中，包含执行基本数值运算的静态方法。

Character 类

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。

String 类

用来创建和操作字符串。

StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

数组

用来存储固定大小的同类型元素

声明数组变量：

dataType[] arrayRefVar;   // 首选的方法
或
dataType arrayRefVar[];  // 效果相同，但不是首选方法

声明和创建数组可以用一条语句完成

dataType[] arrayRefVar = new dataType[arraySize];
另一种方法
dataType[] arrayRefVar = {value0, value1, ..., valuek};

多维数组

// 动态初始化
type[][] typeName = new type[typeLength1][typeLength2];

For-Each 循环

被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

for(type element: array)
{
    System.out.println(element);
}