JavaSE的方法总结

基础语法

注释

单行注释”//“

多行注释

文档注释

标识符

关键字

Java所有的组成部分都需要名字。雷鸣，变量名以及方法名都被成为标识符。

数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

弱类型语言

Java的数据类型分为两大类

基本类型

引用类型

整数

进制

二进制0b

八进制0

十进制

十六进制0x 0~9 A~F

类型转换

强制转换

从高到低

注意：

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 转换的时候可能出现内存溢出或者精度问题

转换类型的时候再需要转换的数据前面加（）并写上想要转换的类型

（类型）变量名

解决溢出问题的时候，先对变量进行类型转换，再进行运算。

自动转换

从低到高，编译程序自动转换

变量

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

变量作用域：

类变量：static

实例变量：从属于对象，如果不进行初始化，会使用默认初始化的值

局部变量:必须声明和初始化

type varName [=value] [{,varName[=value]}];

//数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类型变量。

注意：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。

• 变量名必须是合法的标识符。

• 变量声明是一条完整的语句，因此每一个声明必须以分号结束。

常量

变量命名规则

运算符

短路运算

int c=5;
boolean d = (c<4) && (c++<4);
System.out.println(d);

d在判断的时候前半部分错了，就不会去运算后半部分了，也就不会有自加运算了。

字符串连接符 +

输出：

1020

30

原因：从左往右运算，当遇见字符串类型时，会将剩下的a,b两个int类型转换为字符串输出。

三元运算符

x ? y : z

如果x==true，则结果为y，否则结果为z。

a++于++a

++在前先自增在赋值，++在后先赋值再自增

流程控制

Scanner

我们可以通过Scanner类来获取用户的输入

基本语法：

Scanner s=new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasnext()与hasnextLine()判断是否还有输入的数据。

scanner用完后关闭

scanner.close();

两种next方法的区别

顺序结构

程序顺序向下执行。

选择结构

if单选泽结构

equals：判断字符串是否相等

字符串尽量不用==来判断

if双选择结构

if多选择结构

嵌套的if结构

switch的多选择结构

break防止case穿透

switch 语句的变量类型可以是：

• byte,short,int或char
• 从Javase7开始支持字符串String类型了
• 同事case标签必须为字符串常量或自变量

循环结构

while循环

do...while循环

while先判断后循环，do...while先循环一遍后判断

for循环

增强型for循环

break&&continue

break：在任何循环语句的主体部分，均可用break控制循环的流程。break用于强制退出循环，不执行循环中剩余语句

continue：用在循环语句体中，用于终止某次循环跳过该次循环未执行的指令，进行下一次循环判断

continue可以通过后接outer来指定跳转位置

package scanner;

public class Demo06 {
    public static void main(String[] args) {
        //打印101-150以内的质数

        outer:for (int i = 101; i < 150; i++) {

            for (int j = 2; j < i/2; j++) {

                if (i%j==0){
                    continue outer;
                    }
            }
            System.out.print(i+" ");
        }
    }
}

Java方法

静态方法（带static）当程序加载的时候就存在了：直接调用，

非静态方法（只有当类实例化后才存在）：先实例化再进行调用。

方法：是语句的集合，他们在一起执行一个功能。

• 方法是解决一类问题步骤的有序组合
• 方法包含于类或者对象中
• 方法在程序中被创建，在其他地方被引用

形式参数：用来定义作用的

实际参数：实际调用传递过来的参数

方法的定义

方法的调用

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

规则：

• 方法名称必须相同
• 参数列表必须不同（个数不同或类型不同，参数排列顺序不同等）
• 方法的返回类型可以相同也可以不同
• 仅仅返回类型不同不足以构成方法的重载

实现理论：方法名称相同时，编译器会根据用方法的参数类型，个数等进行匹配，以选择对应的方法，如果匹配失败，则编译器报错。

根据传入的实参不同，调用不同的方法，所以一个类中可以存在相同的函数名称但是形参不同的函数，即为方法的重载。

package method;

public class Demo02 {
    public static void main(String[] args) {

        double num=da(66.6,66.0);
        System.out.println("最大值为："+num);
    }

    public static int da(int num1,int num2){

        int i;
        if (num1==num2){
            System.out.println("两个值相同");
            return num1;

        }else if (num1>num2){
            i=num1;
        }else {
            i=num2;
        }
        return i;
    }

    public static double da(double num1,double num2){

        double i;
        if (num1==num2){
            System.out.println("两个值相同");
            return num1;

        }else if (num1>num2){
            i=num1;
        }else {
            i=num2;
        }
        return i;
    }
}

命令行传参

运行程序的时候再传入参数，这要靠传递命令行参数给main函数实现

可变参数

对于demo03这个类，调用该类下的方法，需要用到new demo03，然后在引入局部变量，就可以调用该类下的方法了。

对于int...i：相当于一个数组，可以传入参数时，传入int类型的参数若干，形成一个i【】的数组，即，输出的时候使用数组的方式输出，例如i【0】，输出第一个数字。

package method;

public class Demo03 {
    public static void main(String[] args) {

        Demo03 demo03 = new Demo03();
        demo03.test(5,6,7);
    }
    public void test (int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
    }
}

递归

递归就是：A方法调用A方法，自己调用自己

package method;

public class Demo04 {
    public static void main(String[] args) {
        //递归

        System.out.println(f(3));
    }
    public static int f(int n){
        if (n==0){
            return 1;

        }else {
            return n*f(n-1);
        }
    }
}

数组

相同类型数据的集合

通过下标来访问

数组的创建：

int[] num;//定义数组
int[] num2=new int[10];

三种初始化：

package array;

public class Demo01 {
    public static void main(String[] args) {
        //静态初始化
        int[] a={0,1,2,3,4,5,6,};
        System.out.println(a[2]);

        //动态初始化
        int[] b = new int[11];//分配空间，默认初始化

        b[10]=10;
        System.out.println(b[10]);
        System.out.println(b[0]);
    }
}

数组使用的一些方法实例。

package array;

import java.lang.reflect.Array;

public class Demo03 {
    public static void main(String[] args) {
        int[] array={1,2,3,4,5,6,};

        //printArray(array);
        int[] back = back(array);//把反转的数组存储到数组back中
        //在通过打印数组方法打印出来back数组

        printArray(back);

        //jdk1.5以上，没有下标的循环
//        for (int i : array) {
//            System.out.println(i);
//
//        }

    }
    //打印数组的静态方法
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);

        }
    }

    //反转数组
    public static int[] back(int[] array){
        int[] a = new int[array.length];
        for (int i = 0,j=a.length-1; i < array.length; i++,j--) {
            a[i]=array[j];

        }
        return  a;
    }
}

Arrays类

可以通过调用类里面的工具来实现对数组的编辑和使用。

package array;

import java.lang.reflect.Array;
import java.util.Arrays;//通过调用这个工具类里面的方法来实现的

public class Demo04 {
    public static void main(String[] args) {
        int[] a={1,2,3,888,666,10000,666,888};

        //调用方法来排序
        Arrays.sort(a);
        //利用array打印数组
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

比较数组相邻的两个元素，让小的元素往前移，直到固定到第一位为最小的元素，即为第一轮完成。每次轮都会产生一个最小的元素。

package array;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //冒泡排序

        int[] a={1,2,5,6,888,666,10000,4,3,999};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array){
        for (int i = 0; i < array.length-1; i++) {

            //定义一个临时变量用于交换
            int temp=0;
            //外层循环用于判断需要对数组进行几次
            //内层循环用于比较相邻两数字的大小，并进行交换
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]>array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }

            }

        }return array;
    }
}

对象

面向对象的本质就是：以类的方式组织代码，以对象的组织封装数据。//记住这句话

三大特性：封装；继承；多态。

类与对象的区别

类是一种抽象的数据类型，它是对某一类事物整体的描述/定义，但是并不能代表某一具体的事物。

对象是抽象概念的具体实例。

创建于初始化对象

使用new关键字创建对象：

一个类中有属性和方法两部分构成

类是抽象的

属性也就是字段，用于定义一些类型

方法在调用字段的时候，通常用this.加定义的字段来调用

类在main方法中需要先实例化出来

类实例化之后会返回一个自己的对象

用new 加类名来实例化，并将其返回到一个对象上

package oop.Demo03;

//学生类
public class Student {

    //属性：字段

    String name;
    int age;

    //方法

    public void study(){
        System.out.println(this.name+"在学习");
    } 

}

构造器

1. 和类名相同
2. 没有返回值

作用：

1. new本质在调用构造方法
2. 初始化对象的值

注意：定义了有参构造如果想使用无参构造，需要定义一个显示的无参构造。

alt加insert会自动生成构造器

小总结

1. 类与对象：类是一个模板，抽象的，对象是一个具体的实例

2. 方法 定义，调用！！

3. 对象的引用：

   引用类型：基本类型

   对象是通过引用来操作的

4. 属性，字段field 成员变量

   默认初始化，引用类型为null，数字类型为0

   修饰符 属性类型 属性名=属性值

5. 对象的创建与使用

   必须使用new关键字创造对象，构造器 Persong person=new Persong（）；

   对象的属性 persong.name

   对象的方法 person.sleep()

6. 类

   静态的属性 属性

   动态的行为 方法

封装

高内聚，低耦合。

封装：通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有：get/set

private：私有

由于使用private后，属性变为私有，无法直接调用属性，所以类里面应该提供一些public的get set方法

get：获取这个数据

set：给这个数据设置值

作用：

1. 提高了程序的安全性，保护数据
2. 隐藏了代码的实现细节
3. 统一接口
4. 系统的可维护性增加了

继承

this.指向当前类

super.指向父类

在Java中，所有的类默认直接或间接继承object类

ctrl加h在类中调出来继承树

extends的意思是扩展，子类是父类的扩展。

public class Stduent extends Person
    public//公共
    protected//保护
    private//私有 

学生 is 人，学生类（子类）继承了人（父类）

子类继承了父类，就会拥有父类的全部方法

私有的无法继承

在Java中，所有的类都默认继承object类

注意点

super：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法！

this：

代表的对象不同：

	this：本身调用者这个对象

​ super：代表父类对象的应用

前提

​ this：没有继承也是可以使用的

​ super：只能在继承条件才可以使用

构造方法

​ this（）：本类的构造

​ super（）：父类的构造

在new一个新的对象的时候，会优先调用父类的无参构造，再去调用子类的无参构造。

重写

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

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，但是不能缩小。
4. 抛出的异常：范围可以被缩小，但是不能扩大。

重写，子类的方法和父类必须要一致，方法体不同

为什么要重写：

1. 父类的功能子类不一定需要或者不一定满足！

   ALT+Insert：override

多态

多态存在的条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类

多态的注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常 ！！ ClassCastException
3. 存在条件：继承关系，方法需要重写，父类的引用指向的是子类对象！！———— Father a=new Son（）；

不能重写的，所以也就不会有多态

1. static：方法，属于类，它不属于实例
2. final：常量
3. private：方法，私有

注意：多态是方法的多态，属性没有多态性

instanceof

用于判断一个对象是什么类型，与其他对象有啥关系

强制转换

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型，可以直接转，但是会丢失子类中原本可以直接调用的（子类）特有方法。
3. 把父类转换为子类，向下转型，需要强制转换，会丢失掉子类对父类重写的方法。
4. 方便方法的调用，减少重复的代码，简洁！！

子类可以直接使用父类的方法，但是父类不能直接使用子类的方法

如果父类想要使用子类的方法，需要强制转换为子类，再使用子类的方法。

//Student能调用的方法都是自己的或者父类的
Student s1 = new Student();
//Person是父类，虽然可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();

//子类重写了父类的方法，就会去执行子类的方法
//s2.eat();
((Student) s2).eat();
s1.eat();
((Student) s2).eat();

static

package oop.Demo08;

public class Student {
    public static int age;//静态变量

    public double score;//非静态变量

    public static void main(String[] args) {


        Student s1 = new Student();//new一个对象
        System.out.println(s1.score);//通过创建对象来调用变量
        System.out.println(Student.age);//通过类来调用变量
        //如果想调用非静态的方法，必须new出来
        s1.eat();
    }

    public static void run(){//静态方法
        //但是在静态的方法里面不能调用非静态的方法

    }
    public void eat(){//非静态方法
        run();//在非静态方法里面可以去调用静态的方法
    }
}
/*
        非静态方法可以去调用静态的方法
        但是静态的方法不可以调用非静态的方法
        静态的方法可以调用静态的方法
        static和类一起加载
 */

运行顺序

package oop.Demo08;

public class Person {
    {
        //执行顺序
        //静态》匿名》构造
        //匿名代码块
        //赋初始值
        System.out.println("匿名代码块");
    }
    static  {
        //静态代码块
        //一般用于加载一些初始数据
        //和类一起加载，永久只执行一次
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==============");
        Person person2 = new Person();
    }
}

抽象类

加了abstract就是抽象类，或者抽象方法

1. 不能new这个抽象类，只能靠子类去实现它
2. 抽象类中可以写普通的方法
3. 抽象方法必须在抽象类中

package oop.Demo09;

//abstract  抽象类  类只能extend：  单继承
//接口可以实现多继承
public abstract class Action {
    //abstract 抽象方法，只有方法名，没有方法的实现！！
    public abstract void doSomething();
}
/*
子类
package oop.Demo09;

//抽象类的所有方法，继承它的子类，都必须要去实现它的方法
//除非子类也是abstract的抽象类
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

 */

接口

普通类：只有具体实现

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

接口：只有规范，自己无法写方法，专业的约束！约束和实现分离

package oop.Demo010;

//抽象类：extends
//类，可以实现接口 implements 接口
//实现接口的类必须重写接口中的方法
//多继承--利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void time() {

    }

    @Override
    public void update(String name) {

    }
}
/*
两个接口
package oop.Demo010;
//interface  定义的关键字     接口都需要有实现类
public interface UserService {
    //接口中所有的定义其实都是抽象的，默认为public abstract，所以不用写了
    void add(String name);
    void delete(String name);
    void update(String name);

}



package oop.Demo010;

public interface TimeService {
    void time();
}

 */

接口的作用

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法默认为public abstract
4. 常量默认为public static final，即无法修改
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

实例化

实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = new 类名（参数1，参数2...参数n）构成。

就是new一个对象的过程称为实例化

但是抽象类和接口不能被实例化

　Calendar c = new Calendar(); 出现 new Calendar()就会执行实例化一个对象了。所以如果是抽象类就不能这样new的。要new 它没有abstract的子类。

　　抽象类是指不允许被实例化的类；抽象方法是没有方法体的方法。
　　1、抽象类可以不包括抽象方法，它反正不会去实例化，抽象类不能被实例化，也就是不能用new关键字去产生对象，抽象方法只需声明，而不需实现，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类，里面的方法是不是抽象的没有本质影响。
　　2、但是含有抽象方法的类绝不能被实例化，否则执行这个方法的时候，怎么办？
　　3、如果子类是非抽象的，那么它就必须实现父类中的抽象方法；否则，它继承来的抽象方法仍然没有方法体，也是个抽象方法，此时就与“含有抽象方法的类必须是抽象类”相矛盾了。

　　抽象类与接口紧密相关，它们不能实例化，并且常常部分实现或根本不实现。抽象类和接口之间的一个主要差别是：类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承。从抽象类派生的类仍可实现接口。可以在创建组件时使用抽象类，因为它们使您得以在某些方法中指定不变级功能，但直到需要该类的特定实现之后才实现其他方法。抽象类也制定版本，因为如果在派生类中需要附加功能，则可以将其添加到基类而不中断代码。

　　在实现抽象类时，必须实现该类中的每一个抽象方法，而每个已实现的方法必须和抽象类中指定的方法一样，接收相同数目和类型的参数，具有同样的返回值

Mybatis

一