Java基础

基本数据类型：数字，非数字

数字：整数（byte， short，int，long)，小数（floot(单精度)，double(双精度))

非数字：char(字符)，boolean(1,0)

引用：类（class),接口（interface),数组（array),字符串（String）

命名规范

只能用英文，下划线，数字，$结尾

只能用英文 ，下划线，$开头

不能使用关键字

## 运算符

“=”作用

把右边的数据放到左边的空间里

“/”除商

“%”取余

“==”只能判断基本数据类型

“&&”连接，都满足，逻辑与：前一个不成立后一个条件不执行

“&”按为与：不管前面是否成立都会执行后一个

“||”或，满足一个 逻辑或：前一个条件成立后一个不执行

“|”按位或：前一个条件不管是否成立后一个都会执行

“!”非   "!="

判断

if(判断条件){

--->代码块

}else if(){

--->代码块

}else{

--->代码块

}

接下来看一下案例：

switch(a.equals){//.equals判断字符串

    case 1:

--->代码块

        break;

    case 2:

--->代码块

        break;

    default:

--->代码块

        break;  

}

接下来看一下案例：

循环

要搞清楚什么时候（条件）做什么事的操作

循环变量大多数时候的作用是记录循环次数

### for

基于数字递增的循环

执行顺序

1. 声明 ：int i=0；

2. 循环条件：i<10;决定了循环多少次

3. 被循环的代码：

4. 迭代：i++

5. 再次进入循环条件，当循环条件不满足就结束当前循环

案例：

while

while(循环条件){

    循环体

    迭代

}

案例：

三个关键词：

break: 结束循环

continue :跳过本次循环

return: 结束方法

数组

存储**同一种数据类型**的多个数据

在内存空间划出一串连续的相同类型的空间

多个变量的组合

数组是JAVA里面的数据结构

会出现的异常

ArrayIndexOut:7//数组下标越界

int[] array = new int[];

数组中的下标（从0开始的）->数组中对应该下标位置上的数据

Arrays.toString(array);//展示数据

int[] y =Arrays.copyOf(i,i.length+1);//用来复制数组，并可以让数组长度+1

Arrays.sort(array);//将数组元素，升序排列

案例：

方法

修饰符 返回值（没有：void) 方法名（参数类型，参数名）{

方法体

​    return 返回值（没有返回值就不写）

}

定义一个方法

public void jishu(){

   

}

使用

Test a = new Test();

a.jishu();

参数

在编写时**必须使用**的数据，知道类型，但不确定是什么的内容的时候使用

用类名创建出来的叫对象

**传达参数：数量一样，顺序一样，类型一样**

return 结果；

面向对象

包，类，对象

包

com.xinzhi.Test

类

public class Test{}

对象

A a = new A();

面向对象三大特征

封装：

alt + Ins

public String getUsername() {

        return username;

    }

public void setUsername(String username) {

    this.username = username;

}

继承：

当有一个A类，B类，在B类中写

public class B extends A {}

一个子类只能有一个父类

super.a

//增加代码可读性,来自A类的a

私有化的不能被继承

public class A{

   private int a;

}

public class B extends A{

    //无法访问到A中的属性a

}

构造方法 创建类的对象

public class A{

    public A {

        //初识化

    }

}

//静态块

static{

   

}

//代码块

{  

}

/*

静态块先运行证明类加载完了

代码块  执行

构造 运行

*/

没有编写JAVA默认会提供一个无参无代码构造

可以写多个，通过参数分辨（数量不同，顺序不同，类型不同）

方法重载：

方法名相同，参数列表不同，同一个类中才发生的

**重写（overide)**

***之间没有任何关系***

**重载（overload)**

public int a(){}

public int a(String b){}

抽象类

public abstract class C{}

这是抽象类，抽象类不能创建对象所以没有构造方法，可以有正常的属性和方法，抽象父类中可以有抽象方法，抽象方法只能在抽象类中，子继承抽象父必须重写抽象方法

public abstract class C {

    public abstract void c();//抽象方法

    //抽象方法中可以传参，抽象方法定义方法编写的规则

}

public class B extends C {

    @Override

    public void method() {

       

    }

}

接口：

接口中的方法是全局抽象

没有构造方法一说

接口中的变量==>全局静态常量

public interface C {

    void method();

}//这是接口

public class B implements C {

    @Override

    public void method() {

    }

}

//这是用

多态

用相同类型的空间放入不同类型的内容

public class  A {

   public  void a(){

        System.out.println("a");

    }

}

public class B extends A {

    public void a() {

        System.out.println("b");

    }

}

public class C extends A {

   public void a() {

        System.out.println("c");

    }

}

public class D_Main{

    public static void main(String[] args) {

        A a = new B();

        A b = new C();

        a.a();

        b.a();  

    }

}

//输出结果b,c

向上转型

小的向父类转换：自动类型转换

A c = new B();

向下转型：

父向子转换：强制类型转换

B c = (B)a;

//instanceof

if (a instanceof B){}

//判断对象是什么类型的

异常

IoException

RuntimeException //运行异常

处理异常

try {

    写可能会出现异常的代码

}catch(Exception e){

    //处理异常

    //可以写多个

}finally{

    //无论try是否异常都会执行

}

抛出异常

public  void a() throws NumberFormatException{

让调用方法的地方进行异常处理

throw new NumberFormatException();