后端java三小时速通笔记（仅代表个人观点，应该有很多错误，欢迎指正）

1.基本语法

注释的三种类型：a. //xxxx...(只适用于一行) b./......../(可以跨行)c.用得少

标识符：由连续的英文、下划线的组成的含有独立意义的结构单元，如变量名、类名……命名规则参考python,但增加了"&"符号

关键字（以及保留字）：基本可认为是已占用的有本身意义的标识符（如if,break...）,不可用于自定义的变量名

2.简单的输入输出

输入：即读取使用者的给出信息。

首先要调用Scanner类，即\"import java.util.Scanner"\从而使用Scanner用于获取外部信息

在输入时，最好能将输入的内容进行赋值（先定义一个变量来存储输入的内容），如：

Scanner input=new Scanner(System.in);
int num;
num=input.nextInt();

其中input是新创建的Scanner类中的一个对象（名字随意更换，只要不是保留字和中文就行应该)，2,3行代码可以合并为\"int num=input.nextInt()"

要赋值的变量需要先声明其类型，nextInt表示读入下一个输入的整数类型，Int换成Double,Float等表示读入相应的类型的量

读入一整行可使用\"nextLine"实现

输出：将需要的结果展示给用户

主要方法有：

System.out.print("输出结果为："+res);
System.out.println("输出结果为："+res);

这里out是System中的一个对象，print是对out执行的方法，其中print表示直接输出无其他操作，而println表示输出后将光标移到下一行（相当于自动换行）

有时若不方便直接换行可采用如下方法

 while(location<djx){
                if(location==(delta+1)||location==(djx-delta-1)){
                    System.out.print("*");
                }
                else{
                    System.out.print(" ");
                }
                if(location==djx-1){
                    System.out.println();

                }
 ```
 注意到，只需在每一行输出结束时换行，故可以在每次内循环结束时执行一次
```java
System.out.println();

什么也不输出，只换行

格式化输出（一般用于实数的精度保留）

由于输出的东西本质上是字符串，所以可以用以下的方法：

System.out.print("有唯一实根为：" + String.format("%.4f", key));

其中%为占位符，提醒要进行格式化输出，4代表保留的小数位数（根据精度需求自行更改），key是输出的结果

3.基本数据类型和运算

数据类型

整数类：4种，最常用的应该是int（吧），

浮点类（暂时认为是小数）：float和double两类，主要是精度不同

逻辑类（布尔运算）：只有两种：true和false,且无法强制转变为其他类型

字符串类：不知道算不算，由数字，字母和其它字符组成的整体，自成一类

运算

基本的加减乘除，对某一变量进行操作时可简写为类似

a+=5;
b-=2.3;
c*=8;
d/=15

等形式

其中加减乘完全符合数学常规，对除法有以下情况：

/：若除数和被除数均为整数型则表示除以后取整数部分（去掉小数点和之后的部分），如：

3/2=1;
-5/3=-2;

对于整除情况不影响，对于出现结果是小数的等价于：正数向下取整，负数向上取整

若被除数和除数有一个是double或float型（5.000这种也算），则执行实数除法（不直接取整），而是直接得到double类型的结果

%：整数相除取余数，若c=a/b,d=a%b,则d=a-b*c

逻辑运算符：太多了不详细写了就

其中"&&"表示与，“||”表示或，比较常用

a++与++a的区别：1.嵌套其他复合运算时，++a优先级更高，会先给a加上1再进行其他操作；2.a++的值是临时变量，无法作为赋值对象，而++a值为a,可以赋值；

逻辑运算：请学习逻辑代数

4.控制结构

分支结构(switch不太用就不写了)

if (delta > 0) {
                double key1 = (delta - b) / (2 * a);
                double key2 = (-delta - b) / (2 * a);
                System.out.print("两个根分别是：" + String.format("%.4f",key1) + "," + String.format("%.4f",key2));
            } else if (delta == 0) {
                double key = (-b) / (2 * a);
                System.out.print("有重根为：" + key);
            } else {
                System.out.print("无实根");

由 保留字 if,else if,else和对应的分支操作组成，按情况分别执行，可以只有if（只有一种情况要操作），也可以是if+elif(两种及以上的情况给予不同的操作)，还可以是if+else

由于可以没有else，可能有些情况不会执行任何操作

elif 可以写很多个，代表多种不同的情况

循环结构

比较实用的是for 和 while两种（个人认为）

for 循环实例：

for(int x=1;x<10;x++){
        sum+=x;//sum初值先定义好是0
        }

for 的结构：

for(初始条件；结束条件；每轮变化){

循环体

}

for循环有着较为严格的结构要求，降低了失误率，但某种程度上也降低了灵活性，而while循环可以解决很多for无法解决的问题

上面的求和代码用while来写，可以写作：

int x=1;
while(x<10){
     sum+=x;
     x+=1;
}

显然while的括号中只有结束条件，初值和变化都要另外写，因此“x+=1；”非常重要，否则会死循环

由于while只规定了结束条件，更有利于解决未知循环次数的问题（比如验证角谷猜想）

do...while...和while的区别：前者先执行后判断（至少执行一次），后者先判断后执行（可以一次都不做）

5.类、对象、方法和实例；

本人认为以下这段代码大致上包括了这几者间的“微妙”关系：

package Dog;
import java.util.Scanner;
public class Dog {
    public Dog(String name){
        /*该构造方法只有一个参数，即name*/
        System.out.println("狗名为："+name);
    }
    public Dog(){
    }//第二次使用Dog构造对象，但无实际作用，只是为了用里面的方法
    int DogAge;/*定义一些属性*/
    int Left;
    public void setAge(int year){
        DogAge=year;//作用只是设置年龄，无返回值
    }
    public int getAge( ){
        System.out.println("狗年龄为："+DogAge+"年");
        return DogAge;//交互输出设置的年龄
    }
    public static void main(String[] args){//主方法部分，协调统一其他方法
        Dog Zbw=new Dog("张百万");//创建一个叫Zbw的对象
        int yea;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入该狗年龄：");
        yea=sc.nextInt();
        /*以下三句调用对象的方法执行一些操作              */
        Zbw.setAge(yea);
        Zbw.getAge( );
        Zbw.LfTime( );
    }
    public int trans(int cishu) {//将被弹次数转化为剩余寿命的函数方法
        int temp;
        if(cishu<10000){
             temp=10-cishu/1000;
        }
        else{
             temp=0;
        }
        return temp;
    }
    public int LfTime( ){
        System.out.println("请输入该狗被弹只因的次数：");
        Scanner input=new Scanner(System.in);
        int cishu=input.nextInt( );
        Dog LeftLife=new Dog( );//重新创建一个对象，无实际含义
        Left=LeftLife.trans(cishu);
        System.out.println("该狗剩余寿命为:"+Left+"天");
        return Left;//非void类型要有输出
    }
}

类：顾名思义，是具有某些特征的东西的总称，往往规定了这些东西所对应的属性和行为，相当于模具用于刻画具体不同的个体

类又分为系统预定义和自定义的，系统定义的常见的有用于输入的Scanner,表示字符串的String等，上面的代码自定义了一个名为Dog的类

类的模板作用：规定了对象可能具有的属性，如Dog类中有DogAge(狗的年龄)、left(狗的剩余寿命)等，可以供不同的狗使用；

对象：在类的范畴下的具有不同属性特征的个体，一个类中显然可以创建多个不同的对象，他们可以具有不同的对应属性（不同年龄和剩余寿命）

变量：主要依据所在的位置进行分类：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

行为(方法)：对对象进行的操作（如本例中的GetAge、LfTime），可进行调用操作，与python中的自定义函数类似

构造方法：不用另外写，类自带的与类名相同的方法，且至少要调用一个（这段代码调用了两次，但是输入的参数类型不同故可视为不同的方法而不会混淆）

6.数组

一种对象，有对应的属性（如长度），其存储空间大小是固定的且在内存中是连续存放的，存储大小在定义时已确定不随元素个数变化而改变

一维数组的定义方法：

//定义可以容纳10个整数的数组
//方法一：
int[] scores=new int[10];
int scores[]=new int[10];//可读性差
//方法二：
int[] scores;
scores=new int[10];//最佳方法，其中10代表数组规模大小
//方法三：
int[] scores={99,98,99,97,96,92,93,94,98,99};

第一、二种定义之后还需要将数组元素初始化进行赋值，可以按照索引一个个进行赋值，例如：

      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;

这种方法效率显然不高，对于有规律的数组元素也可以用循环的方式进行赋值

要找到数组中的某一个元素可以直接用索引进行定位，但索引从0开始，如数组规模为10时，索引值范围为0到9

多维数组：以低一维度的数组作为元素的数组，如二位数组是最简单的多维数组，举个栗子：

int[][] a = new int[2][3];

该语句创建了一个两行三列的二维数组，数组a中有两个元素，每个元素是含有三个元素的一维数组，其中的单个小元素可以用二维数对来定位，如a[1][2]

7.继承

一种实用的机制，允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法。子类可以继承父类的成员，然后扩展或修改它们。

继承机制承前启后，有利于模块化写作，减少了不必要的代码

继承机制类似于树结构，每个节点最多只有一个前驱节点，但可以有多个后驱节点，即类可以多层继承（有爷爷、太爷爷。。。），但不能多重继承（有两个以上的爸爸），且所有的类与祖先类属相同

8.基本的修饰符类型

public

类公开可见

（成员）数据、方法公开可见

一个Java文件中，只能有一个public类，遵循封装原则，public不应该修饰数据成员

protected

对于其子类，或者同一个包中的类可见

protected成员，在其他包中只能通过继承的方式来使用

缺省 default

整个类的访问权限是本地

对于同一个包中的类，可见

缺省类，其成员的最高访问权限为缺省，尽管可以用public，protected修饰，

private

私有，仅对本类或者其外部类公开

final

禁止方法被覆写

禁止类被继承

yyt