Java学习笔记

本文主要是介绍Java学习笔记，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

## 常用缩写(可以自定义)

psvm:生成main函数

```java

public static void main(String[] args){

}

```

sout:生成输出函数

```jave

 System.out.println();

```

选定语句快捷键 ctrl+alt+t:生成捕获错误函数

```java

try {

            System.out.println(a/b);//为选定的语句

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

        }

```

用类实现接口 快捷键ALT+Insert 选 overide

```java

public class UserServiceImpl implements UserService {

    //选所有方法不会报错

    @Override

    public void add(String name) {

    }

    @Override

    public void delete(String name) {

    }

    @Override

    public void update(String name) {

    }

    @Override

    public void query(String name) {

    }

    

}

```

ctrl+h 展现出继承关系：

 

ctrl +D：

复制代码至下一行

 

# 类型转换：

**注意点：**：

- 不能对布尔值(boolean，只能为其变量赋值true和false)进行转换

- 不能把对象类型转换为不相干的类型

- 高容量转换为低容量的时候强制转换可能内存溢出或者精度问题。

## 强制转换（高->低）：（类型）变量名

```java

int i=128;

byte b=(byte)i;

```

## 自动转换（低->高):

```java

int i=128;

double b=i;

```

# 运算符：优先级()

## 算术运算符

+、-、*、/；

a+=b;//a=a+b;

a-=b;//a=a-b;

自增：a++(执行完代码后，再自增，即先用后加) a=a+1

       ++a(执代码前，先自增，即先加后用)

自减同理a--、--a

幂运算：需要用工具函数来执行；

```java

double a=Math.pow(3,2);//即a为3的二次方，输出为9.0；

```

## 逻辑运算符：

&&（与）、||（或）、!（非）

- a&&b 与运算 有假为假

- a||b 或运算 有真为真

- !a、!b 非运算 假为真，真为假

- !(a&&b)异或运算 同号为假，异号为真

短路运算：当*与运算*时，若靠左的逻辑运算若为假，则不继续走右边逻辑运算，直接结束运算。

## 位运算符：

&与、|或、^异或、~、>>、>>>、<<

```java

/*

A=0011 1100

B=0000 1101

-----------------------------

A&B 0000 1100(都为1则为1，有一个非1为0)；

A|B 0011 1101(都为0则为0，存在一个1直接为1)；

A^B 0011 0001(相同为0，不同为1)；

~B 1111 0010（取反）

2<<3 2左移3位 0000 0010->0001 0000 则结果为16

>>右移除二

<<左移乘二

*/

```

## 三元运算符

```java

//? :

//x?y:z   (如果x==true，则结果为y,否则为z)

```

# 包机制（类似于C语言中的头文件，一些代码需要包才可运行）

一般利用公司域名**倒置**作为包名：com.baidu.www

- import package1[.package2...].(classname|*)；

- package com.kuang.operator;

# 用户交互scanner

- C语言中的scanf:

```

String str=scanner.nextLine();

String str=scanner.next();

```

```java

//创建一个扫描对象，用于接收键盘数据

        Scanner scanner=new Scanner(System.in);

        System.out.println("使用next方式接受：");

//判断用户有没有输入字符串

        if(scanner.hasNext()){

            //使用next方式接受，

            String str = scanner.next();//可将next改成nextLIne

            System.out.println("输出的内容为"+str);

        }

//记得关闭防止占用资源

        scanner.close();

    }

``` 

- next()：有空格断掉

- nextLine():以Enter为结束符，可以获得空白

## 条件输入

用if语句输出int、float或其它类型的字符串。

```java

 Scanner scanner=new Scanner(System.in);

        System.out.println("使用整数方式接受：");

        int i=0;

        float f=0.0f;

        //输出int类型数字

        if(scanner.hasNextInt()){

            i=scanner.nextInt();

            System.out.println("输出的整数内容为"+i);

        }else{

            System.out.println("输入的不是整数");

        }

        System.out.println("使用小数方式接受：");

        //输出float类型数字

        if(scanner.hasNextFloat()){

            f=scanner.nextFloat();

            System.out.println("输出的小数内容为"+f);

        }else{

            System.out.println("输入的不是小数");

        }

//记得关闭防止占用资源

        scanner.close();

```

# 结构

## 顺序结构

除非特别指明，否则就按照顺序一句一句执行，他是任何一个算法都离不开的一种基本算法结构。

## 选择结构

- if单、双、多选择结构、嵌套的if结构（if里面还有if，二分查找比较常见）

```java

    //多选择为例

    if(布尔表达式1){

    }else if{

    }else{

    }

    //else语句在所有else if语句之后，一旦其中一个else if语句检测为true，其他的都跳过执行。

```

- switch多选择结构

```java

    int a;

    switch(a)//可以是byte、short、int、char

        case()://case标签必须为字符串常量或者字面量

            //输入语句 

            break;

        case():

            //输入语句

            break; 

        default:

            //输入语句

```

## while循环：

只要布尔表达式为true，循环就会一直执行下去

```java

while(布尔表达式){

    //循环内容

}

```

## do-while循环：

必定先执行一次，再检验while中的布尔表达式。

```java

    do{

    //循环内容

}while(布尔表达式);

```

## for循环

是最有效最灵活的循环结构。

```java

for(初始化;布尔表达式;更新){

    //代码语句

}

```

- 在idea中输入 100.fori

  系统将自动生成：

```java

  for(int 1=0;i<100;i++){

  }

```

- 在idea中输入 100.forr系统将自动生成：

```java

  for (int i1 = 100; i1 > 0; i1--) {

            

    }

```

### 增强for语句：

for(声明语句：表达式)

```java

    int [] numbers={10,20,30,40,50};

    for(int x:numbers)//将数组每一项遍历出来，遍历给x。

    {

        System.out.println(x);

    }

```

## 循环终止

- break指令：在任何循环语句的主体部分junkeyongbreak控制循环流程，用于**强行退出循环**不执行循环中剩余语句

- continue指令：语句用在循环语句体中，用于**终止某次循环**

# 方法

- 类似于C语言中的函数

break 和return 的区别:

return 代表方法结束，返回值需要与参数类型相同

break 代表跳出switch、结束循环

参数列表：(参数类型，参数名)...

方法定义：

```java

修饰符 返回值类型 方法名(形参){

    //方法体

    return 返回值:

}

```

```java

    public static void main(String[] args) {

    int sum=add(1,2);

        System.out.println(sum);

    }

    //加法

    public static int add(int a,int b)//括号内为形参

    {

        return a+b;

    }

```

- 可变参数

  

  在方法声明中，在**指定参数类型后**加一个省略号（...)

  一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何**普通参数必须在他之前**声明。

```java

    public void test(int ...i){

    }

```

## 递归

- 自己调用自己，需要有结束条件

递归结构包括两部分:

递归头：什么时候不调用自身方法。如果没有头，将进入死循环

递归体：什么时候需要调用自己

```java

    //  递归算阶乘

    public static int f(int n){

        if(n==1){

            return 1;

        }else{

            return n*f(n-1);

        }

    }

```

# 数组

- 数组是相同类型数据的有序集合

- 数组长度是固定的

- 数组可以是任何数据类型，包括基本类型和引用类型

- 数组对象本身是在堆中

## 数组声明和创建 

定义：

```java

int[]nums;//首选声明类型

int nums2[];//C语言风格

nums=new int[10];//创建一个数组

int [] num=new int [10];//创建与声明相结合

int [] numbers={10,20,30,40,50};//定义数组：

```

## 数组长度

获取数组的长度:arrays.lenth

## 初始化

```java

//静态初始化:

int[]a={1,2,3,4,5,6};

System.out.printle(a[0]);

//动态初始化：包含默认初始化（一被分配空间后，没被赋值的都为0或NULL)

int[]b=new int[10];

b[0]=10;

```

## 数组边界

下标的合法区间:[0,length-1]

如果越界就会报错:**ArrayIndexOutOfBoundException**:数组下标越界异常 

## 数组使用

```java

    int[]arrays={1,2,3,4,5};

    //打印所有数组元素

    for(int i=0;i<arrays.lenth;i++){

        System.out.println(arrays[i]);

    }

    //计算所有元素的和

    int sum=0;

    for(int i=0;i<arrays.lenth;i++){

        sum+=array[i];

    }

    //查找最大的元素

    int max=array[0];

    for(int i=1;i<arrays.lenth;i++){

    if(arrays[i]>max){

        max=arrays[i];}

    }

    //反转数组

    int[]restlt=new int[arrays.lenth];

    for (int i = 0,j=result.lenth-1; i <arrays.lenth ; i++,j--) {

         result[j]=arrays[i];   

        }

        return result;

```

输入arrays.for 即可自动生成增强型for循环

```java

    for(int array:arrays){

    System.out.println(arrays);

    //没有下标

    }

```

## 多维数组

- 多维数组可以看成是数组的数组

```java

//二维数组的定义：

int[][]arrays={{1，2}{2,3}{3,4}};

//三行两列的数组,arrays[0][0]为1，arrays[1][1]为3

// 1，2     

// 2，3

// 3，4

//此时打印的数组长度为3，即外面空间有三个元素

```

## 工具类Arrays

避免重复造轮子，有工具就不用自己再打一遍。

常用功能：

- 给数组赋值:fill

- 输出数组：toString

- 对数组排序:sort

- 比较数组:equals

- 查找数组元素：binarySearch

```java

    int []a={1,3,23,5235,2432,4234};

    //打印数组元素：Arrays.toString

    System.out.println(Arrays.toString(a));

    //结果为[1, 3, 23, 5235, 2432, 4234]

    //排序算法：   

    Arrays.sort(a);//升序

    //之后再打印的结果为[1, 3, 23, 2432, 4234, 5235]

    //数组填充

    Arrays.fill(a,0);//全填为0

    //之后打印结果为[0, 0, 0, 0, 0, 0]

    Arrays.fill(a,1,3,0);//下标1到下标3的值之间填为0

    //之后打印结果为[1, 0, 0, 5235, 2432, 4234]、

```

## 稀疏数组

一种数据结构,一个二维数组很多元素是默认值为0或者为同一值。

处理方式：

- 记录数组几行几列，有多少个不同值

- 吧具有不同值的元素和行列及值记录在一个小规模数组中从而缩小程序规模

 

```java

//创建一个二维数组11*11 0：没有棋子，1：黑棋，2：白棋

        int[][]array1=new int[11][11];

        array1[1][2]=1;

        array1[2][3]=2;

        System.out.println("输出原始的数组");

        for (int[] ints : array1) {

            for (int anInt : ints) {

                System.out.print(anInt+"\t");

            }

            System.out.println();

            //输出结果为：

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   1   0   0   0   0   0   0   0   0

// 0    0   0   2   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

// 0    0   0   0   0   0   0   0   0   0   0

        }

        //转换为稀疏数组保存

        //获取有效值的个数

        int sum=0;

        for(int i=0;i<11;i++){

            for(int j=0;j<11;j++){

                if(array1[i][j]!=0){

                    sum++;

                }

            }

        }

        System.out.println("有效值的个数:"+sum);

        //创建一个稀疏数组的数组

        int[][]array2=new int [sum+1][3];

        array2[0][0]=11;

        array2[0][1]=11;

        array2[0][2]=sum;

        //遍历二维数组array1，将非零的值存放稀疏数组中

        int count=0;

        for(int i=0;i< array1.length;i++){

            for(int j=0;j<array1[i].length;j++){

                if(array1[i][j]!=0){

                    count++;

                    array2[count][0]=i;

                    array2[count][1]=j;

                    array2[count][2]=array1[i][j];

                }

            }

        }

        //输出稀疏数组

        System.out.println("稀疏数组:");

        for(int i=0;i<array2.length;i++){

            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");

        }

        //稀疏数组：

        // 11   11  2   

        // 1    2   1   

        // 2    3   2   

        //给出稀疏数组还原原数组：

        //1、读取稀疏数组

        int[][]array3=new int[array2[0][0]][array2[0][1]];

        //2、给其中的元素还原他的值

        for(int i=1;i<array2.length;i++){

            array3[array2[i][0]][array2[i][1]]=array2[i][2];

        }

        //3、打印

        for (int[] ints : array3 ){

            for (int anInt : ints) {

                System.out.print(anInt+"\t");

            }

            System.out.println();

            }

//输出结果为

0   0   0   0   0   0   0   0   0   0   0   

0   0   1   0   0   0   0   0   0   0   0   

0   0   0   2   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

0   0   0   0   0   0   0   0   0   0   0   

    }

```

# 八大排序

## 冒泡排序

两层循环，外层冒泡层数，里层依次比较（时间复杂度为O（n^2)

```java

//比较数组中两个相邻元素，如果第一个数比第二个数大则会交换位置

//下一轮则会少一次排序

    //第三方变量相交换

    int temp=0;

    //外层循环：判断我们要走多少次；

    for(int i=0;i<array.lenth-1;i++){

        //内层循环：比较两个数的大小

        for(intj=0;j<array.lenth-1-i;i++){

           

        if(array[j+1]<array[j]){//此时为升序，若想为降序则if里面判断的条件为array[j+1]>array[j]

            temp=array[j];

            array[j]=array[j+1];

            array[j]=temp; }

        }

    }

```

# 面向对象

- 本质：以类的方式组织代码，以对象的形式封装数据

- 三大特性：封装、继承、多态

## 类

- 相当于C语言中的结构体

- 类是一种抽象的数据类型，它是对某一类事物整体描述

- 静态的属性、动态的行为

- 类是抽象的，需要实例化

```java

//学生类

public class Student{

    //属性：字段

    String name;

    int age;

}

//实例化

//student对象（下面的小明）就是一个Student类的具体实例

    Student xiaoming=new Stduent();

    xiaoming.name="小明";

    xiaoming.age=3;

    System.out.println(xiaoming.name);

    System.out.println(xiaoming.age);

    //输出为小明 3

```

使用new关键字创建的时候，除了**分配内存空间**之外，还会给创建好的对象进行**默认的初始化**以及对**类中构造器的调用**

## 构造器

- 必须和类的名字相同

- 必须没有返回类型，也不能写void

  

对象的创建和使用：

- 必须使用new 关键字创造对象，构造器 person mosun

- 对象的属性 mosun.name

- 对象的方法 mosun.run()

```java

//构造器实例化初始值

//使用new关键字，必须要有构造器，本质是在调用构造器

//用来初始化值

//对象属性：字段field 成员变量

//默认初始化：

// 数字：0 0.0

// char:u0000

// boolean:false

// 引用类型：null

public Student(){

    this.name="mosun"//没实例化之前类的对象为null

}

//有参构造（alt+insert默认生成有参）：

public Person(String.name){

    this.name=name;

}

//================================================

public class pet {

    public String name;

    public int age;

    public void shout(){

        System.out.println("汪了一声");

    }

}

public class 使用类 {

        public static void main(String[] args) {

            pet dog = new pet();

            dog.name="messi";

            dog.age=3;

            dog.shout();

            System.out.println(dog.name);

            System.out.println(dog.age);

        }

        //输出汪了一声

        //messi

        //3

    }

```

## 封装

**高内聚 低耦合**

```python

//类 private：私有（外部不能使用）

    public class Student{

        private String name;

        private int id;

        private char sex; 

    } 

    //提供一些public 的get.set方法

    //get 获得数据

    public String getName(){

        return this.name;

    }//此后可以在外部使用类的name值

    //set 给数据设值

    public void setName(String name){

        this.name=name;

    }

```

## 继承

extands  拓展：子类是父类的扩展。子类可以继承父类的所有方法

super:调用父类的构造器，且必须要在子类构造器的第一行

```java

//人：父类

public class Person{

    pubilc void say(){

    System.out.println("说话");

    }

    private int money=1_000_000;//私有的，不能被继承

    pubilc void print(){

    System.out.println("Person");

    }

}

//学生是人：派生类、子类：学生

public class Student extends Person{

    pubilc void print(){

    System.out.println("Student");

    }

      

    pubilc void test1(){

    print();

    this.print();//访问该类方法

    super.print();//访问父类方法

    }

}

//老师是人：派生类、子类：老师

public class Teacher extends Person{

      

}

//测试函数：

public static void main(){

    Student student =new Student();

    student.say();//Student类用了Person类的方法

    student.tset1();//输出：Student Student Person

}

//ctrl+h 会展现出继承关系

```

super注意点：

- super调用父类的构造方法，必须在构造方法的第一个

- super必须只能出现在子类的方法或者构造方法中。

- super和this不能同时调用构造方法

super和this的区别:

- 代表的对象不同

- 

        - this:本身调用者这个对象

        - super:代表父类对象的应用

- 前提

- 

        - this:没有继承也可以使用

        - super:只能在继承条件才能使用

- 构造方法：

- 

        - this():本类的构造

        - super():父类的构造

## 多态

动态编译：类型（可拓展性）

- 多态是方法的多态，属性没有多态

- 父类和子类，有联系才可转换，否则类型转换异常（ClassCastException!)

- 存在条件：继承关系,需要重写,父类引用指向子类对象 Father f1=new Son();   

```java

public class Person{

    public void run(){

        System.out.println("run");

    }

}

//学生是人：派生类、子类：学生

public class Student extends Person{

    public void eat(){

        System.out.println("eat");

    }

}

public static void main(){

    //一个对象的实际类型是确定的

    new Student();

    new Person();

    //但是可以指向的引用类型不确定

    Student s1=new Student();

    Person  s2=new Student();//父类型可以指向子类，但是不能调用子类独有的方法

    Object  s3=new Student();//Object是所有类的顶级父亲，也就是始祖

    //s1.run();父类有该方法可以调用

    // s2.eat();父类没有该方法，且不能调用子类的eat方法

    //((Student) s2).eat();强制类型转换，此时就可以用子类方法

}

```

## 方法重写：

重写都是方法的重写，和属性无关，子类方法和父类必须要一致，方法体不同

需要有继承关系，子类重写父类的方法：

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围只可以扩大：public>protected>default>private

4.抛出的异常：范围，可以被缩小，但不能扩大

eg:ClassNotFoundException-->Exception(大)

为什么需要重写：

- 父类的功能子类不一定需要或者不一定满足

Alt+Insert:override

不能重写的方法：

- static方法：属于类，不属于实例

- final 是常量

- private方法：私有方法不能被子类修改

## instanceof(类型转换)

引用类型，判断一个对象是什么类型

延申之前举例的Person、Student、Teacher

有以下关系

```java

//System.out.println(X instanceof Y)编译能不能通过取决于X，Y有无父子关系

//Object>String 

//Object>Person>Teacher

//Object>Person>Student

Object object=new Student();

System.out.println(object instanceof Student);//true

System.out.println(object instanceof Person);//true

System.out.println(object instanceof Object);//true

System.out.println(object instanceof Teacher);//false

System.out.println(object instanceof String);//false

Person person=new Student();

System.out.println(person instanceof Student);//true

System.out.println(person instanceof Person);//true

System.out.println(person instanceof Object);//true

System.out.println(person instanceof Teacher);//false

//System.out.println(person instanceof String);//编译报错

Student student =new Student();

System.out.println(student instanceof Student);//true

System.out.println(student instanceof Person);//true

System.out.println(student instanceof Object);//true

// System.out.println(student instanceof Teacher);//编译报错

// System.out.println(student instanceof String);//编译报错

Person obj=new Student();

(Student)obj; //高类转换为低类

Person person=student//子类转换为父类

```

- 低（子）转高（父）时，由于子已经继承了父的所有，所以删去属于自己的后自然而然就可以转化问父类的；而父想要转子，则需要重新开辟只属于子的空间，则需用强制转换

- 父类引用指向子类，可以调用父类公共的方法，还可以调用子类重写的方法，但是无法调用子类独有的方法，只有通过强制转换才能调用子类的独有的方法

## static(静态变量)

```java

    private static int age;

    private double score;

    public void run(){//非静态方法可以调用静态方法

        go();

    }

    public static void go(){

    }

    public static void main(String[] args){//静态方法只可以调用静态方法里面的东西

        go();

        //run();//不能调用

    }

```

静态代码块的顺序

```java

public class Hello {  

    //2:赋初值

    {

        System.out.println("匿名代码块");

    }

    //1:只执行一次

    static{

        System.out.println("静态代码块");

    }

 

    //3

    public Person(){

        System.out.println("构造方法");

    }

    public static void main(String[] args) {

        Person person=new Person();

    }

    //输出结果：静态代码块 匿名代码块 构造方法

}

```

## 抽象类

abstract修饰 抽象方法只有方法名字，没有方法的实现

- 不能new这个抽象类，只能靠子类去实现他：约束

- 抽象类中可以写普通的方法

- 抽象方法必须在抽象类中

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范，自己无法写方法；约束和实现分离：面向接口编程

接口的本质是契约

## 接口

interface接口

定义约束

定义一些方法，让不同的人实现

```java

public interface UserService {

    //接口中的所有定义其实都是抽象的 public abstr act

    void add(String name);

    void delete(String name);

    void update(String name);

    void query(String name);

}

```

```java

//类可以实现接口 implements 接口(可以实现多个接口)

//实现了接口的类，就需要重写接口中的方法

public class UserServiceImpl implements UserService {

    //快捷键ALT+Insert 选 overide

    //选所有方法不会报错

    @Override

    public void add(String name) {

    }

    @Override

    public void delete(String name) {

    }

    @Override

    public void update(String name) {

    }

    @Override

    public void query(String name) {

    }

    

}

```

# 异常(Exception)

- 检查性异常：用户错误或问题引起的异常

- 运行时异常：编译时看不到，运行时才可以发现

- 错误（Error）：错误不是异常，而是脱离程序员控制的问题，例如栈溢出

## 异常处理框架

- 在Exception分支中有一个重要的子类RuntimeException(运行时异常)

- 这些异常是不检查异常，程序中可以选择捕获处理也可以不处理

    - ArrayIndexOutOfBoundsException（数组下标越界）

    - NUllPointerException(空指针异常)

    - ArithmeticException（算术异常）

    - MissingResourceException(丢失资源)

    - ClassNotFoundException(找不到类)等

 

## 异常处理机制

    try、catch、finally、throw、throws

```java

    int a=1;

    int b=0;

//假设要捕获多个异常，从小到大捕获

    try{//try监控区域

        System.out.println(a/b);

    }catch(ArithmeticException e){//catch 捕获异常

        System.out.println("程序出现异常，变量b不能为0");

    }catch(MissingResourceException){

        System.out.println("程序出现异常，丢失异常");

    }

    finally{//处理善后工作

        System.out.println("finally");

    }

//==================================================================//

//或者选中下行代码，快捷键 ctrl+alt+t，自动把所需要的代码包裹起来，自动包裹处理机制出现上面的捕获代码

System.out.println(a/b);

```

## 自定义异常

只需要继续Exception类即可

- 创建自定义异常类

- 在方法中通过throw关键字抛出异常对象

- 如果在当前异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

- 再出现异常方法的调用者中捕获并处理异常

这篇关于Java学习笔记的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！