软件园学生在线

  • {{ item.name }}
  • 2023试用期

登录与注册

后端零 姚宇涛

  • yyt
  • 2023-10-12
  • 0

后端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
yyt
© 2025 软件园学生在线
Theme by Wing