JAVA基础知识

面向对象的语言
支持以下基本概念

• 多态
• 继承
• 封装
• 抽象

• 重载

  基本概念

• 类：一个模板，描述一类对象的行为和状态

• 对象：类中的一个实例
• 实例：一个具体的案例，比如金毛、柯基。
• 方法：对象的行为
• 属性：对象的方法

基本语法

• 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

  
  编写java程序

  ```java public static void main(String[] args)

修饰符 返回值类型 方法名(参数类型 参数名){ … 方法体 … return 返回值; } //void表示没有返回值

![image.png](https://cdn.nlark.com/yuque/0/2022/png/586762/1645773845669-cc9e578d-81d1-40ab-8d35-395db7406e5e.png#clientId=u785c3d79-149a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=302&id=u26b34c7e&margin=%5Bobject%20Object%5D&name=image.png&originHeight=340&originWidth=831&originalType=binary&ratio=1&rotation=0&showTitle=false&size=91611&status=done&style=none&taskId=u43d4786f-17cf-4d33-98e5-9d98782677e&title=&width=738.5)
<a name="aemyB"></a>
#### 执行java程序
![](https://cdn.nlark.com/yuque/0/2022/jpeg/586762/1645076059892-edf3491f-d0fd-4d77-a743-4244e5bdaf06.jpeg)<br />具体实例
```html
import java.io.*;
public class EmployeeTest{
   public static void main(String[] args){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();
      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

编译并运行

$ javac EmployeeTest.java
$ java EmployeeTest

源文件声明规则

• 一个源文件中只能有一个 public 类
• 一个源文件可以有多个非 public 类
• 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
• 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。

用java包对类进行分类

java基本数据类型

容量小→容量大：自动类型转换，16可以自动转换位32，32可以自动转换位64
容量大→容量小：强制类型转换（转换数据类型必须兼容）
整数默认类型为int
小数默认类型为浮点型

java变量类型

在Java语言中，所有的变量在使用前必须声明

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'

• 类变量（今天变量）：独立于方法之外的变量，用 static 修饰。
  • 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。
• 实例变量：独立于方法之外的变量，不过没有 static 修饰。

• 局部变量：类的方法中的变量。

  • 作用于方法中
  • 需要初始化一个值，否则编译出错

    public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
    public void method(){ 
       int i =0;  // 局部变量
    }
    }

    访问控制修饰符

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。 | 修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 | | —- | —- | —- | —- | —- | —- | | public | Y | Y | Y | Y | Y | | protected | Y | Y | Y | Y/N（说明） | N | | default | Y | Y | Y | N | N | | private | Y | N | N | N | N |

非访问修饰符

• static 修饰符，用来修饰类方法和类变量。
• final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。被 final 修饰的实例变量必须指定初始值。
• abstract 修饰符，用来创建抽象类和抽象方法。
• synchronized 和 volatile 修饰符，主要用于线程的编程。

抽象方法：可以没有实现的方法。

java运算符

2B++先运算再自增，2++B先自增再运算

位运算符（二进制运算后转换为十进制）

逻辑运算符

条件运算符（?:）

variable x = (expression) ? value if true : value if false

java循环语句：for, while 及 do…while

for, while 及 do…while

while( 布尔表达式 ) {
  //循环内容
}
//布尔表达式为true则会一直循环下去

do {
       //代码语句
}while(布尔表达式);
//布尔表达式为true则会一直循环下去，至少能够执行一次

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

java增强for循环

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

break 关键字

break;

continue 关键字

continue;

在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

java条件语句：if…else

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

java switch case 语句

判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

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

当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case (哪怕不匹配)的值都会输出，直到出现break或者跳出循环。

Java Number & Math 类

Java Number类

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

包装类是把普通类型首字母大写，意思是把内置数据类型变为对象，方便使用

Java Math 类

可参考常用类

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

Java Character 类

包装类是把普通类型首字母大写，意思是把内置数据类型变为对象，方便使用

Character ch = new Character('a');

转义序列

Java String 类

创建之后无法修改，如果需要修改，则使用 StringBuffer & StringBuilder 类

String str = "Runoob";
String str2=new String("Runoob");

Java StringBuffer 和 StringBuilder 类

StringBuilder sb = new StringBuilder(10);//创建了10个空位，要插入内容则往10个里面插入。

java数组

声明数组

dataType[] arrayRefVar;   // 首选的方法
//实例
double[] myList;

创建数组

arrayRefVar = new dataType[arraySize];

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

dataType[] arrayRefVar = new dataType[arraySize];

数组可以作为参数和返回值

//作为参数
public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
//作为返回值
public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

多维数组

为数组分配空间

type[][] typeName = new type[typeLength1][typeLength2];
String[][] str = new String[3][4];

String[][] s = new String[2][];
s[0] = new String[2];//定义几行
s[1] = new String[3];//定义几列
s[0][0] = new String("Good");//定义内容
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

引用方式

num[1][0];

java日期时间

用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。 | | 10 | 获取当前时间 | String toString( )
把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。 |

使用 SimpleDateFormat 格式化日期

SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");

使用printf格式化日期

%t+字母
实例里面又在后面家里%n，不知道为什么

解析字符串为时间：parse()

没理解

Java 休眠(sleep)

Thread.sleep(1000*3)//毫秒为单位

Calendar类

set设置

c1.set(Calendar.YEAR,2008);

add设置

c1.add(Calendar.DATE, 10);//日期加上10，10天后

get设置

int year = c1.get(Calendar.YEAR);

java正则表达式

• Pattern 类
• Matcher 类
• PatternSyntaxException类

捕获组

通过左括号确定组

((A)(B(C)))
为以下四个组
((A)(B(C)))
(A)
(B(C))
(C)

语法

使用\双反斜杠匹配字符，比如\n匹配n
单反斜杠有特殊含义，比如\n匹配空格

Matcher 类

java方法

命名规则
方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。

构造方法

每个类都有一个默认构造方法，一旦你定义了自己的构造方法，默认的构造方法就会失效。

• 没有返回值
• 大多数时候需要一个有参数的构造方法
• 构造函数首字母和后面单词的首字母

可变参数

一个方法只能制定一个，必须是方法最后一个参数。
制定参数类型后加一个省略号

typeName... parameterName

finalize() 方法

protected void finalize()
{
   // 在这里终结代码
}

Java 流(Stream)、文件(File)和IO

没看懂

Java Scanner 类

通过scanner获取用户输入

next() 与 nextLine() 方法

next()遇到空白会将其截断
nextLine()可以获得空白，以enter为结束符

Java 异常处理

用户错误
程序错误
物理错误

多重捕获块

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型3 异常的变量名3){
  // 程序代码
}

throws/throw 关键字

finally关键字

• try的最末尾
• 无论是否发生异常，finally 代码块中的代码总会被执行。

  try{
  // 程序代码
  }catch(异常类型1 异常的变量名1){
  // 程序代码
  }catch(异常类型2 异常的变量名2){
  // 程序代码
  }finally{
  // 程序代码
  }

java继承

继承格式

class 父类 {
}
class 子类 extends 父类 {
}

重复的代码会造成代码的臃肿，所以需要继承

公共父类

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

以上为示例父类，以下为从父类继承的子类。（类似sketch的组件概念）

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

java不支持继承多个父类。但是可以多重，比如儿子再到孙子，也可以不同类继承同一父类。

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。（牵一发而动全身）

  extends关键字

  在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

  implements关键字

  使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。以下为示例 ```java public interface A { public void eat(); public void sleep(); }

public interface B { public void show(); }

public class C implements A,B { }

<a name="zo2HD"></a>
#### super 与 this 关键字
super访问父类成员<br />this访问子类成员
```java
class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}

final关键字

将类定义为不能继承的，不能被子类重写

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

构造器

super进行调用，有参数要求则传对应的参数，没有的话无需使用super进行调用，系统会自动调用

Java 重写(Override)与重载(Overload)

重写规则

• 参数列表与被重写方法的参数列表必须完全相同。
• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个类，则不能重写该类的方法。

重载

同一个方法为了应对各种不同参数的情况使用而建立的。

java多态

同一个行为具有多个不同表现形式或形态的能力
同一个事件发生在不同的对象上会产生不同的结果。

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

示例

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
abstract class Animal {  
    abstract void eat();  
}  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

虚函数

java中所有都是虚函数

java抽象类

不能实例化对象，其余的功能全部存在。父类不能使用自己的方法，只有子类能够使用。
使用 abstract class 来定义抽象类

抽象方法

抽象方法只包含一个方法名，而没有方法体。
抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

public abstract double computePay();

声明抽象方法会造成以下两个结果：

• 如果一个类包含抽象方法，那么该类必须是抽象类。
• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。