自用Java基础1

JDK : Java Development Kit（开发工具包）

JRE : Java Runtime Environment（运行时环境）

JVM : JAVA Virtual Machine（虚拟机）

idea用法

方法1

File -> New Project -> Java ->1.8版本 -> next -> next -> 安装位置

src -> new ->Java Class

方法2

File -> New Project -> Emply Project -> next -> finsh -> x

File -> New -> Module -> 工程名字

File ->Project Structure -> project <No SDK>改为1.8 语言对应8 -> apply

设置（Settings） -> 编辑（Editor） ->

基础中的基础

阿里巴巴格式

【强制】抽象类命名使用Abstract或Base开头;异常类命名使用Exception结尾:测试类命名以它要测试的类的名称开始，以Test结尾。

(32条消息) 必读开发规范之阿里巴巴开发手册(个人整理版)_阿里开发手册_Apple_Web的博客-CSDN博客

注释

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释

        /*
        多行注释
         */

        /**
         * 文档注释
         * JavaDoc注释 
         */
        System.out.println("Hello World!");
    }
}

标识符

是类名、变量名以及方法名。

• 所有的标识符都应该以字母(A-Z或者a-z)，美元符($)、或者下划线(_）开始

• 首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线（_）或数字的任何字符组合

• 不能使用关键字作为变量名或方法名。

• 标识符是大小写敏感的

数据类型

Long类型要在数字后面加个L float类型要在数字后面加个F

public class Demo03{
    public static void main(String[] args){
//进制    二进制0b    十进制    八进制0    十六进制0x
    int i = 10;
    int i2 = 010;
    int i3 = ox10;
    system.out.print1n(i);
    System.out.print1n(i2);
    System.out.print1n(i3);
    }
}

强制转换：b = int(a)

自动转换：double i = b

i=97.0

变量

是可以变化的量，可以是基本类型，也可以是引用类型。

所有的变量、方法、类名：见名知意，首字母小写的驼峰形式。

常量

final double PI =3.14; //一般大写

运算符

算术运算符    +，-，*，/，%，++，--
赋值运算符    =
关系运算符    >，<，>=，<=，==，!=instanceof
逻辑运算符    &&，||，!
位运算符      &，|，^，~，>>，<<，>>>(了解!!! )
条件运算符    ?:
扩展赋值运算符 +=，-=，*=，/=

包机制

package akg1 [.pkg2 [.pkg3...] ];

JavaDoc

是用来生成自己的API文档的

java class -> open in -> explorer

在文件的导航地址最前面/删了加: cmd (空格)+enter

cmd里面加上以防乱码，Doc.java是文件名

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

点开index.html跳转网页

流程控制

用户交互Scanner

Scanner s = new Scanner(System.in);

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

scanner scanner = new Scanner(System.in);
//创建一个扫描器对象，用于接收键盘数据
system.out.println("使用next方式接收:");

//判断用户有没有输入字符串
if (scanner.hasNext()){
    //使用next方式接收
    string str = scanner.next();
    system.out.println("输出的内容为: "+str);
}
//凡是属于Io流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉
scanner.close();

next():

1、一定要读取到有效字符后才可以结束输入。

2、对输入有效字符之前遇到的空白,next()方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4、next()不能得到带有空格的字符串。

nextLine():

1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。

2、可以获得空白。

if选择结构

//单选择
if(布尔表达式){
    //如果布尔表达式的值为true
}

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

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

switch多选择结构

switch (grade){
    case 'A':
    system.out.print1n("优秀");//语句
    break;//可选

    case 'B':
    System.out.println("良好");
    case 'c' :
    system.out.println("及格");
    case 'D' :
    System.out.println("挂科");
    default : //可选
    System.out.println("输入错误");//语句
}

while循环

先判断再循环

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

do...while循环

先循环再判断，至少会循执行一次

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

for循环

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

增强for循环

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

//数组的下标是从0开始的
for (int i = 0; i<5; i++){
    system.out.println( numbers[i] );
)

for (int x : numbers){
    System.out.println(×);
}

break、continue

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

continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

“标签”是指后面跟一个冒号的标识符，例如：label:

对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另-个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

方法

System.out.println()
System是系统的类
out是对象
println()是一个方法

定义

修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return返回值;
}
修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
参数类型：当方法被调用时，传递值给参数，这个值被称为实参或变量。还有用于接受外界输入数据的形式参数。

方法的调用

调用方法:对象名.方法名(实参列表)

Java支持两种调用方法的方式，根据方法是否返回值来选择。当方法返回一个值的时候，方法调用通常被当做一个值。例如:

int larger = max( 30，40);

如果方法返回值是void，方法调用一定是一条语句。

System.out.print1n("Hello,kuangshen!");

形参、实参

实际参数和形式参数的类型要对应。

值传递和引用传递

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.print1n(a); //1
        Dempoe4.change(a);
        System.out.println(a); //1
    }
    //返回值为空
    public static void change(int a){//形式参数，传过来就没了
        a=10;
    }
}

//引用传递:对象，本质还是值传递
public class Demo05 {
    pub1ic static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name); //null
        Demo05.change (perosn);
        System.out.println(perosn.name); //秦疆
}
    public static void change(Perosn perosn) { perosn.name = "秦疆"; }
}
//定义了一个Perosn类， 有一个属性: name
class Perosn{
string name; //null
}

静态方法、非静态方法

//学生类
public class Student {
    //静态方法
    public static void say(){
        System. out. print1n("学生说话了");
    }
}

//调用的程序
public class Demo02 {
    public static void main(String[] args) {
        Student.say();
}

//学生类
public class Student {
    //非静态方法
    public void say(){
        System. out. print1n("学生说话了");
    }
}

//调用的程序
public class Demo02 {
    public static void main(String[] args) {
        //实例化这个类new，对象类型 对象名=对象值
        Student student=new Student();
        stdent.say();
    }
}

方法的重载

方法名称相同时，参数列表必须不同。返回类型可同可不同。

编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传递参数

可变参数

JDK 1.5开始，Java支持传递同类型的可变参数给一个方法。在方法声明中，在指定参数类型后加一个省略号(.…)。

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

public class Demo04 {
    public static void main(string[] args){
    Demoe4 demoea = new Demo04();
    demoe4.test( ...i: 1,2,3,4,45,5);
    }
    public void test(int... i){
        system.out.println(i[0);
        system.out. println(i[1]);
        System.out.println(i[2]);
    }
}

递归

A方法自己调用自己

public static void main(string[] args) {
    system.out.println(f( n: 4));
}

public static int f(int n){
if (n==1) {
    return 1;
}else {
    return n*f( n: n-1);//阶乘
}
//24=4*3*2*1实际上是1*2*3*4*5

数组

定义

数组变量属引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保持原始类型还是其他对象类型，数组对象本身是在堆中的。

[0, length-1]

ArraylndexOutOfBoundsException:数组下标越界异常!

dataType[] arrayRefVar;//首选的方法或
dataType arrayRefVar[];//效果相同,但不是首选方法。
//java里面dataType[]才是数组，第二个更类似于C

创建数组

dataType[ ] arrayRefVar = new dataType[arraysize];

//动态初始化：包含默认初始化
int[ ] nums; //定义
nums = new int[10]; //这里面可以存放10个int类型的数字
nums[0] = 1;//赋值

//静态初始化：创建＋赋值
int[] nums2 = {1,2,3};

数组的元素是通过索引访问的，数组索引从0开始。

获取数组长度：arrays.length

内存分析

多维数组

二维数组

int a[][] = new int[2][5];
int[][ ]array = i,2},{2,33,{3,4},{4,5};

二维数组a 可以看成一个两行五列的数组。

Arrays类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是“不能")

具有以下常用功能:

给数组赋值:通过fill方法。

对数组排序:通过sort方法,按升序。

比较数组:通过equals方法比较数组中元素值是否相等。

查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;
public class ArrayDemoe6{
    public static void main(string[] args) {
    int[] a = {1,2,3,4,9090,31231,543,21,3,23};
    //system.out.println(a); // [I24554617c
    //打印数元素Arrays.toString
    //Systems.out.printLn(Arrays.tostring(a));
    Arrays.sort(a);//数组进行排序:升序
    System.out.println(Arrays.toString(a));
}

冒泡排序

总共八大排序

冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。

算法的时间复杂度为O(n2)。

//1 比较数组中两个相邻的元素，如果第二位比第一位大，我们就交换他们的位置
//2 每一次比较，都会产生出一个最大的数字，下一轮可以少一次排序!
//3 依次循环，直到结束!比如下面例子11个数，10*9*8*7*6*5*4*3*2*1
public class ArrayDemoe7 {
    public static void main(string[]args) {
        int[] a = {1,4,5,6,72,2,2,2,25,6,7};
        int[] sort = sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
    }
    public static int[] sort(int[] array){
        int temp = 0;//临时变量

        //外层循环，判断我们这个要走多少次;
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，比价判断两个数，如果第一个数，比第二个数大，则交换位置
            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;
}

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是:

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

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

[0] 6行，7列，8个有效数字

[1] 0行，3列，数字22

public static void main(String[] args) {
//1.创建一个二维数组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();
    }
    //转换为稀疏数组保存//获取有效值的个数
    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);

    //2.创建一个稀疏数组的数组
    int[][] array2 = new int[sum+1][3];
    array2[0][0] = 11;
    array2[0][1] = 11;
    array2[0][2] = sum;
    //遍历二维数组，将非零的值，存放稀疏数组中
    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");
    }

    //3.读取稀疏数组
    int[][]array3 = new int[array2[0][0]][array2[0][1]];
    
    //给其中的元素还原它的值
    for (int i =1; i < array2.length; i++) {
        array3[array2[i][0]][array2[i][1]]= array2[i][2];
    }
    //打印
    system.out. print1n("输出还原的数组");
    for (int[] ints : array3) {
        for (int anInt : ints) {
            system.out.print(anInt+"\t");
        }
    }
}   

面向对象

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。

三大特性:封装、继承、多态

从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板。

对象是通过引用来操作的：栈 -> 堆

类和方法的区别：有无返回值？

对象的创建和使用

• 必须使用new关键字创造对象，构造器Person kuangshen = new Person();

• 对象的属性kuangshen.name

• 对象的方法euangshen.sLeep()

类

静态的属性 属性

动态的行为 方法

类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物（如：人类）

对象是抽象概念的具体实例，能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念（如：张三就是人的一个具体实例）

封装

该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;
低耦合:仅暴露少量的方法给外部使用。

封装（数据的隐藏)

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

记住这句话就够了:属性私有，get/set

public class Student{
    //属性私有,公有为public
    private String name;
    private int id;
    private char sex; 

    //提供一些public的get、set方法，alt+insert
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String nane){
        this.name = name;
    }
}

//main测试中引用：
Student s1 = new Student();
s1.setName("让get方法获得值");
System.out.println(s1.getName());

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模,

• extands的意思是“扩展”。子类是父类的扩展。

• JAVA中类只有单继承，没有多继承!

• 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系.

//学生 is 人
public class student extends Person{
}

object类

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

super

super

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

this:

代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this();本类的构造
super():父类的构造!

方法重写（多态）

重写都是方法的重写，和属性无关。

这个例子子类父类方法一样

子类中没有注解的时候：Ａ　Ｂ

有注解的时候：A　A（重写）

说明静态的方法和非静态的方法区别很大，非静态才是重写。

重写:简要有继承关系，子类重写父类的方法!
1　方法名必须相同
2　参数列表列表必须相同
3　修饰符:范围可以扩大但不能缩小: public>Protected>Default>private
4　抛出的异常:范围，可以被缩小，但不能扩大:ClassNotFoundException -->Exception(大)

子类的方法和父类必要一致:方法体不同!

为什么需要求写:
父类的功统,子英不一定需要,或者不一定满足
Alt+ Insert : override;

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

条件
有继承关系
子类重写父类方法
父类引用指向子类对象

多态注意事项:
1　多态是方法的多态,属性没有多态
2　父类和子类，有联系　类型转换异常! classcastException !
3　存在条件:继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son();

不能重写
1. static静态方法，属于类，它不属于实例
2. final常量;
3. private方法:

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

instanceof

没有父子关系就会报错

System.out.println(X instanceof Y);//能不能编译通过!

1　父类州时指两子类的对象
2　把子类转换为父类,向上转型
３　把父天转换为广类,向下转型。强制转换
4　方便方法的调用,减少重复的代码

static

抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。约束。

抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

接口

接口可以多继承（插头），父类可以继承，接口要实现。

普通类:只有具体实现

抽象类:具体实现和规范(抽象方法)都有!

接口:只有规范!自己无法写方法。接口不能被实例化，接口中没有构造方法。专业的约束！约束和实现分离：面向接口编程

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class,声明接口的关键字是interface

接口中所有的定义其实都是抽象的　public　abstract

接口都需要有实现类，实现类用Impl结尾

//实现了接口的类，就需要重写接口中的方法
public.class.usenSecyiseImpl.implements UsenService{
    //常量　public static final
}

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

1. 成员内部类

public class outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
//获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

public static void main(string[]args){
Outer outer =new outer();
//通过这个外部类实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getID();

2. 静态内部类

3.局部内部类

4.匿名内部类

异常

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

ArraylndexOutOfBoundsException(数组下标越界)

NullPointerException(空指针异常)

ArithmeticException(算术异常)

MissingResourceException(丢失资源)

ClassNotFoundException(找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM)一般会选择终止线程; Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

异常处理五个关键字

try、catch、finally、throw.throws