第一周Java学习总结


目录

 

 

学习内容:

一、关键字

1、定义:

2、关键字的分类

二、标识符

1、定义

2、标识符命名规则

注意事项:

三、常量

1、定义

2、常量的分类

四、变量

1、定义

2、变量语法:

3、变量的分类

五、数据类型

1、定义

2、引用数据类型与基本数据类型的区别

六、数据类型的转换

1、为什么需要进行数据类型转换

2、数据转换分类

自动类型转换

强制类型转换

七、运算符

1、定义

2、运算符分类

八、条件判断

1、if条件分支

2、if...else条件分支

3、if...else if ... else 多条件分支

4、嵌套条件判断

5、选择条件判断

6、case穿透问题

九、循环

1、循环定义

2、while循环

3、do...while循环

4、for循环

5、嵌套循环

十、数组

1、数组定义 

2、 数组特点

3、创建数组

4、数组的访问

 


学习内容:

一、关键字

1、定义:

在Java程序中,已经定义好的被预先使用的一些特殊的单词称为关键字 ,一共有50个关键字 (48+2个保留字) ,关键字都是小写的英文单词

2、关键字的分类

  • 数据类型关键字

byte :字节类型,   short : 短整型,   int : 整型,   long: 长整型,   float :单精度浮点型

double:双精度浮点型,   char: 字符型,   boolean : 布尔类型,   void :空类型,   null :空对象

  • 流程控制关键字

if: 条件分支判断,   else:条件分支,   switch: 条件分支判断,   case : 条件分支其中一种情况

default : 默认,   break: 退出条件 或 循环,   continue : 退出当前循环,继续下一次循环

for : 循环,   do: 循环,   while : 循环,   return:方法的返回

  • 面向对象关键字

class:定义类,   interface : 定义接口,   extends:继承一个类,   implements: 实现一个接口

super : 超级 (用于调用父类的成员),   this: 当前类,   instanceof : 判断一个类的类型

import : 导入一个类,   package : 定义一个类所在的包,   new : 创建对象

  • 修饰符关键字

abstract :修饰抽象类 、抽象方法,   final : 修饰常量,   native: 本地的 ,也用于修饰变量

private :私有的,   protected : 受保护的,   public : 公共的,   static :静态的

synchronized :修饰方法或代码块,用于线程安全的,   transient :瞬时状态,   volatile :瞬时状态

  • 异常关键字

try:试一试,   catch: 捕获异常,   finally: 最后执行的代码块 ( 多出的一个)

throws :定义需要抛出的异常,   throw:抛出异常

  • 其他关键字 

assert :测试中的断言,   strictfp : 其他,   enum:定义枚举

  • 保留字

const ,   goto

二、标识符

1、定义

在Java程序中,所有由程序员自己命名的元素统称为“标识符”

2、标识符命名规则

  • 标识符由数字、字母、下划线和$组成

  • 标识符不能以数字开头

  • 标识符区分大小写

  • 标识符不能是关键字

注意事项:

定义类名的标识符 :首字母必须大写 ,后面的单词的首字母大写,准寻 大驼峰命名法 (例如 XxxXxx ,UserInfo ,Student)

定义方法 标识符: 首字母尽量小写 ,后面的单词首字母大写,准寻 小驼峰命名法(例如 xxxXxxx , getUserName() )

定义变量标识符: 单词全部小写 ( username)

定义包名: 按模板分层级, 使用公司的域名 倒写,(例如 com.softeem.xxx 、com.j2008.xxx)

定义项目名: 尽量使用英文 (Java项目 可以使用中文,JavaWeb项目一定使用英文)

三、常量

1、定义

在Java中,固定不变的数据量称为常量,常量也有内存,常量存放在被称为“常量池”的内存中

常量的修饰符 : final

final  int  n = 100 ;       // 定义常量的语法 ,n的值只能为 100,不能再次改变 ,其中n就是常量

2、常量的分类

整数常量,   小数常量,   字符常量,   字符串常量,   布尔常量,   空常量

四、变量

1、定义

在Java中用于保存一个数据的最小内存单元 称为 “变量” ,变量中每次只能存放一个值 ,变量的数值是可以被改变的 。

在定义变量时,需要明确三要素: 数据类型 、 变量名(标识符)、变量值

2、变量语法:

数据类型 变量名 = 初始值;

或者 数据类型 变量名1 ,变量名2 ;

// 定义一个变量 变量名是n ,数据类型是int ,初始值为100  
int  n = 100 ; 
// 将原有变量名n中的值变更为 110  
n=110;

3、变量的分类

  • 全局变量(global variables)

在Java的类结构中,定义在类中,方法外面的变量, 它的作用范围: 整个类的方法中

public class Test1 {
    //定义全局变量 :定义在类里面,方法的外面
    int n = 100;

    //定义方法
    public void m(){
        // 输出一句话  "" 表示输出的内容    + 表示连接两个字符串
        System.out.println("n:"+n);
    }
    
    //定义方法
    public void s(){
        System.out.println("n:>>>"+n);
    }
}
  • 局部变量(local varibable)

一般声明在方法或代码块(条件语句块,循环语句块,静态语句块等) 中,它的作用范围只能在声明的区域中使用

// 定义run方法
    public void run(){
        // 局部变量   只能在声明所在的方法中使用
        int  n=200;
        int  i =1;
        // 当类总存在局部变量和 全局变量同名时, 变量的使用遵循“就近原则”
        System.out.println("局部变量n:"+ n);   // 200
    }

    // 定义eat方法
    public void eat(){
       // System.out.println("i---"+i);
    }
  • 调用方法的语法
public static void  main(String [] args){
        // 如何调用 这个类的方法呢?  需要创建对象
        // 创建对象的语法:  类名 对象名 =  new  类名();
        //调用对象的方法语法:   对象名.方法名();
        Test1 obj = new Test1();
        obj.m();
        obj.s();
        obj.run();
        obj.eat();
    }

五、数据类型

1、定义

Java是一门强类型的编程语言,它不同于一些弱类型的语言(JavaScript ,php,python),Java在声明变量时必须显示的定义变量的数据类型,变量的类型一旦定义,则不能改变 。 Java中数据类型分为两大类

1、基本数据类型 : 包括 整数,浮点,字符,布尔类型等

2、引用数据类型 :包括 类,数组,集合,接口等

2、引用数据类型与基本数据类型的区别

1、创建方式不同 ,基本数据类直接通过定义变量的方式创建, 而引用数据类型需要new一个对象

2、在JVM的内存分配不同, 基本数据类型的内存在栈内存中直接创建 , 而引用数据类型是在栈内存中定义引用的地址,实际的内存分布在堆内存中

3、引用数据类型 可以调用它的方法, 而基本数据类型没有方法

六、数据类型的转换

1、为什么需要进行数据类型转换

在Java中数据进行计算时 ,必须要求计算的元素的数据类型一致,如果数据类型不一致需要进行转换

2、数据转换分类

  • 自动类型转换

转换规则: 范围小的类型向范围大的类型转换(从小到大转换)

byte -> short -> int-> long -> float -> double 其中boolean类型不参与转换

char ->int

转换原理: 类型向上提升

  • 强制类型转换

  • 整数之间的强转
 // int 类型
          int i=1;
         // byte 类型
         byte  j=100;
         // 由于i和j 不同类型,不能直接计算,程序会自动将j的类型向上提升为 int
         // 所以i +j 之后依然是  int 类型
         // 此时 int 的内存 大于  byte 的内存,会出现数据溢出的情况 ,JVM不允许
         // byte s = i + j ;   // 等号两遍类型不匹配
         int y = i + j ;
         System.out.println(y);

         // 如果一定要使用byte赋值,还有一种办法,就是将两遍类型一致
         byte s  = (byte)(i + j) ;   // 两个数在相加时 会先自动提升为int 然后再相加
  • 整数与小数之间的强转
// 整数和小数之前 也会丢失精度
        int n2 = 100;
        double n3 = 3.5;
        int n4 = (int)(n2 + n3);
        // 相加时先提升为 double ,然后相加后得到 double
        // double是8个字节 不能放在4个字节的长度中,
        // (这里好比double 为一桶水, int为一杯水,相当于将一桶水往一杯水中放)
        // 只能留住一本水的内容,所以  这里 如果强转成int 则小数会丢失,
        System.out.println(n4);
  • 小数和小数之间的强转
// float  与 double 类型
        float f1 = 3.14f;
        double d2 = 3.5;
        double dd =  f1+d2;
        float  ff =  (float)(f1 + d2);
  • 丢失精度的情况
 // 强转时会丢失精度
        byte n=100;
        int  m = 30;
        byte mm = (byte)( n + m); // 因为最大值为127  再往后就是从最小值开始-128
        System.out.println(mm);

        // 整数和小数之间 也会丢失精度
        int n2 = 100;
        double n3 = 3.5;
        int n4 = (int)(n2 + n3);

 

 

七、运算符

1、定义

在Java中用于程序计算的操作符统称为运算符

2、运算符分类

  • 算术运算符
 public static void main(String []  args){
        //  +  -  *  /  %    所有运算符在计算式必须保证 数据类型一致
        int num1 = 100;
        int num2 = 200;
        int sum = num1 + num2;
        int mul =  num1-num2;
        int num3 = -num2;   // -200
        System.out.println("两个数相加" +  sum); // + 表示连接符
        System.out.println("两个数相减" + mul);
        System.out.println( "num2: " + num2+ " ,num3:" + num3 );
        System.out.println("num1+num2="+ (num1+num2) );


        int sum2 = num1*num2;
        int sum3 = num1/num3;
        System.out.println(sum3);   // 控制台输出的快捷键 sout+ enter
       // System.out.println(num1/sum3); //算术异常:ArithmeticException: / by zero
        // 取模
        System.out.println( 10%2);//0
        System.out.println(1%5);// 1
        System.out.println(2%5);
    }
public static void main(String[] args) {
// 自加  自减     ++  -- 只能对整数进行
        int i=1;
        i++ ;     // i = i + 1
        System.out.println("i:" + i);
        int j=1;
        ++j;    // j = j + 1
        System.out.println("j:" + j);

        int a =1;
        int sum = a++;  // 先将a的值赋值给sum  ,a再自加1
        int sum2 = ++a; // 先将a自加1 ,再将自加后的结果赋值给sum2
        System.out.println("sum:" + sum);
        System.out.println("sum2:" + sum2 );
        System.out.println("a:" +a);  // 3

        int sum3 = a++ + a++ ;
        System.out.println("sum3:"+sum3);
        System.out.println("a:"+a);

        // -- 操作  与++操作类似
        int b=1;
        int s1= b--;  // b = b -1     s1 的值为 先赋值再自减1   s1 = 1
        int s2 =  --b; // b = b -1   s2 的值为 先自减1 ,再赋值  s2 = -1
        System.out.println("b:"+b);
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);

        // ++  --  综合
        int x=1;
        int y=2;
        int s3 = x++ + --x * (y-- + ++x);
        System.out.println("x:"+x);// 2
        System.out.println("y:"+y);// 1
        System.out.println("s3:"+s3);// 5
    }
  • 比较运算符

用于比较两个表达式之间的 结果 , 结果返回true 、false

比较运算符不能单独作为 一行代码运行 ,必须接收结果或者输出

public static void main(String[] args) {
          // 比较运算符
        int a =1;
        int b =2;
       // a>b;  // 不能单独比较 必须接受结果或输出
        System.out.println(a>b);  //false
        System.out.println(a<b);  //true
        System.out.println(a==b); //false
        System.out.println(a!=b); //true
        // 增加逻辑判断
        // 如果 if 后面的条件成立,  则执行if里面的语句 ,如果不成立 则只需else语句
        if(a>b){
            System.out.println("a>b成立");
        }else{
            System.out.println("不成立");
        }

    }
  • 赋值运算符

将表达式 的结果 赋值给一个变量,只能赋值给变量 不能赋值给常量

例如: a = 3

 // 赋值运算符 = +=  -= *=  /=  %=
        int a=2;
        a+=2;
        System.out.println(a);// 4
        a-=3;
        System.out.println(a);// 1
        a*=2;
        System.out.println(a); // 2
        a/=4;
        System.out.println(a);// 0

        a+=a-=3; // a+=(a-=3) -》 a=a +(a=a-3 )
        System.out.println("a="+a);

        int x=2;
        x+=x-=x*=x++;
        //x = x +(x = x -( x= x *(x++) ))
        // x = 2 + ( x = 2 - (x = 2 * 2))
        // x =  2 + ( 2 - 4)
        // x = 0
        System.out.println("x="+x);

        //赋值运算符的优先级最低,  从右往左计算
        int y=2;
        y*=y+=y; // 也是从右往左计算
        // y = y * (y = y + y);
        // y = 2 * (2+2)
        // y =8;
        System.out.println("y="+y);

 

 

 

  • 逻辑运算符

在Java中用于两个或两个以上的表达式 取逻辑判断的结果 ,通常需要使用逻辑运算符

 // 逻辑运算符
        System.out.println(true & true); // true
        System.out.println(true & false);// false
        System.out.println(false & true); // false
        System.out.println(false & false);// false
        // true&true
        System.out.println(1>0 & 3>1);
        System.out.println(1>0 && 3>1);
        // | 或
        System.out.println(true | true); //true
        System.out.println(true | false);// true
        System.out.println(false | true); // true
        System.out.println(false | false);// false
        // || 短路或
        System.out.println(true || false) ;// true

总结: &与&&的区别 |与||的区别?

回答 :

1、& 对于符号两边的表达式都会执行 && 符号左边为false,则右边不执行

| 对于符号两边的表达式都会执行, || 符号左边为true,则右边不执行

2、 & 、| 两边可以直接写数字, 按位计算 ,短路符号 不能直接运算数字

int a=1;
        int b=2;
     //   System.out.println(a>b && b++>0);  // 符号右边的不运算
     //   System.out.println("b:"+b);

        System.out.println(a>b & b++>0); // 符号两边都运行
        System.out.println("b:"+b);

        // || 与 | 的区别
      //  System.out.println(a>=1 ||  a++<0); // a++ 不执行
      //  System.out.println("a:"+a);

        System.out.println(a>=1 | a++<0 );  // a++ 会执行
        System.out.println("再次输出a :" + a);
  • 位运算符
 //正整数的移位  <<   >>   >>>
        System.out.println(3<<2);  // 12
        System.out.println(7<<3); // 7*8=56

        // 对于正数的无符号右移和 右移 结果一样
        System.out.println(16>>2);// 4
        System.out.println(18>>2);// 4

        System.out.println(5^9);//12


        System.out.println(3>>2);
        System.out.println(3>>>2);

        System.out.println(~5);
// 负数的移位
        // 负数的左移位还是为负数
        System.out.println(-4<<2); // -4*2的2次方 =
        /**
         *   -4的原码: 1 0000... 00000100
         *          *   -4的反码: 1 1111... 11111011
         *          *   -4的补码: 1 1111... 11111100
         *          *   开始移位   2
         *             1 1111... 11110000
         *    最后结果 = 取反+1
         *             1 0000... 00001111  + 1
         *  :
         *             1 0000... 00010000  =-16
         */

        // 补码 = 反码+1
        //负数是对于补码 进行移位   -4/2 =-2
        System.out.println(-4>>1);

        // -16无符号右移2位
        System.out.println(-16>>>2);   //1073741820   
        // -16 的补码算出来
        /**
         * 原码  10000.. 0010000
         * 反码  11111.. 1101111
         * 补码  11111.. 1110000
         *      00111.. 1111100  由于不考虑符号,移动后高位全部补0 变成正数
         *      正数原码和补码一致 这个数即为所得
         *      1073741820
         */
  • 三目运算符

表达式 ? 结果1 : 结果2

当?前面成立时, 整个表达式输出 结果1 ,如果?前面不成立,则输出结果2

// 生成100以内的随机数
        int n = (int)(Math.random()*100);
        System.out.println("n:"+n);
        System.out.println( n%2==0 ?"这个数是偶数":"这个数是奇数");

八、条件判断

1、if条件分支

语法:

if(条件){
    语句块
}
其他代码

解释: 如果条件成立 ,则执行语句块 ,如果条件不成立,则不执行语句块

 // 生成一个100以内的随机数   判断它是否为偶数
        int n = (int)( Math.random()*100);
        if(n%2 == 0){
            System.out.println("这是数是偶数");
        }
        System.out.println("程序结束");

2、if...else条件分支

语法:

if(条件){
       语句块1
  }else{
      语句块2
  }

解释: 如果条件成立, 则执行语句块1 ,如果条件不能力 ,则执行语句块2

int n = (int)(Math.random()*100);
        // n<50 需要买西瓜   >50 需要买葡萄
        if(n<50){
            System.out.println("买了一个大西瓜");
        }else{
            System.out.println("买了一串葡萄");
        }
        System.out.println("n->"+n);
        System.out.println(" 嗯,程序猿的女朋友很高兴,至少买了水果");

3、if...else if ... else 多条件分支

语法:

if(条件1){
     语句块1
 }else if(条件2){
     语句块2
 }else if(条件3){
     语句块3
 }
 ...
 else{
     语句块4
 }

解释: 从条件1开始依次判断,如果条件1 成立,则执行语句块1 ,其他条件不再执行,如果条件2成立,则执行语句块2,其他条件不再执行。。。 依次类推如果条件都不成立,则执行else语句块。 ,最终只执行其中某一个语句块,

// 随机生成90以内的年龄  整数
        int n = (int)(Math.random()*90);
        if(n<18){
            System.out.println("未成年");
        }else if( n<30){
            System.out.println("青年");
        }else if( n<50){
            System.out.println("中年");
        }else if( n<70){
            System.out.println("老年");
        }else{
            System.out.println("晚年");
        }
        System.out.println("n->"+n); 

4、嵌套条件判断

语法: 以上3种格式 ,可以同时使用,在一个if语句再次嵌套if 语句

 // 接收控制台输入 ,  判断 输入的数 是否能被3整除
          // 如果能被3整除,输出这个数除以3的结果,并判断结果能被7整除
           // 如果不能被3整除,判断是否为偶数

        Scanner sc = new Scanner(System.in);
        // 接收控制台输入的整数
        int n = sc.nextInt();
        if(n%3 == 0 ){
            System.out.println("这个数能被3整除");
            // 在if语句中继续判断, 就是嵌套条件判断 ,需要往后缩进
            int result= n/3;
         	if(result%7 == 0){
                System.out.println("这个结果能被7整除");
            }else{
                System.out.println("这个结果不能被7整除");
            }
        }else{
            System.out.println("这个数不能被3整除");
            if(n%2 ==0){
                System.out.println("这个数能2整除");
            }else{
                System.out.println("这个数不能被2整除");
            }
        }

注意 : 嵌套条件时 为了增强代码的可读性,将条件语句块的分支 往后缩进 ,{}作为一个整体

条件语句块中如果只有一个输出语句, 可以省略{},但是为了保证代码的可读性,不建议省略{}。

5、选择条件判断

语法:

switch(表达式){
    case 常量值1:
       语句块1;
      break;    // 语句块接收的标记
    case 常量值2:
       语句块2;
       break;
      ...
    default: 
       语句块3;
       break;
}

注意: switch 的表达式判断 只能等值比较 ,其中case的常量值 类型位: 整数型(byte short int long ),字符型,字符串型,枚举型

byte n = (byte)(Math.random()*7+1);
        switch (n){
            case 1 :
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6 :
                System.out.println("星期六");
                break;
            default :
                System.out.println("星期天");
                break;
        }

6、case穿透问题

在switch中,如果case后面不写break,将会出现穿透现象,也就是说不会执行下一个case的判断条件直接往后运行,直到遇到break,或整体switch结束

九、循环

1、循环定义

在Java程序中,重复的执行某一段代码 这个过程称之为循环, 为了避免出现死循环,循环分为四部分

1、初始条件

2、循环的判断条件 ,条件为true ,则进入循环体

3、循环体

4、迭代变量

2、while循环

语法:

初始条件
  while(判断条件){
      循环体
      迭代部分 (为了改变循环的判断条件)
  }
//计算 1到100的累加之和
        int sum=0;
        int  n=1;
        while(n<=100){
            sum+=n;
            n++;
        }
        System.out.println("n:"+n);
        System.out.println("sum:"+sum);

3、do...while循环

语法:

初始值1
 do{
     循环体2
     迭代部分3
 }while(返回boolean类型的表达式4);

执行顺序: 123-》423 -》423-》423 .。。4 直到条件4为false 则退出循环。

先执行初始值 1,循环体2 ,迭代3

再判断条件4是否成立,成立,继续执行2,3

再判断条件4是否成立,成立,继续执行2,3

...

判断条件4是否成立,不成立,退出

        int i=0;
          do{
              System.out.println("i--"+i);
              i++;
          }while(i<10);

        System.out.println("i===="+i);
        /**
         * 第一遍: 输出 0   i=1
         * 第二遍: 判断 1<10  成立  输出1   i=2
         * 第三遍: 判断 2<10  成立  输出2   i=3
         * .。。
         * 第九遍: 判断8<10  成立  输出8   i=9
         * 第十遍:判断 9<10  成立 输出9    i=10
         * 第十一遍: 判断 10<10 不成立。退出
         *
         *
         */

while循环与do while循环的区别?

while循环先判断条件是否成立,再执行循环体,do while循环 先执行一遍循环体再判断条件。

4、for循环

for循环的升级版就是 foreach循环

for循环通常在明确循环次数的情况下使用, 它也分为四部分

语法:

for(初始值1 ; 循环判断条件2 ; 迭代部分3 ){
     循环体4
 }
 或者
  
 初始值
 for( ; 循环判断条件 ; ){
     
     循环体
     
     迭代部分
 }
 // 他们的区别是 初始值定义在for的外边,就可以在循环外边使用

5、嵌套循环

嵌套循环: 在一个循环语句中,还包含了另一个循环。例如 在一个for循环中还有一个for循环 ,

它的总的循环次数 = 外循环的次数* 内循环的次数

语法:

for(){    // 外层循环

		for(){   // 内层循环

		}

	}

执行顺序: 外层循环 循环一次 ,内层循环循环完整的一遍

案例:

打印直角三角形
* 
* * 
* * * 
* * * * 
* * * * * 
外循环控制打印几行, 内循环控制打印即可* 
思路 : 考虑一行打多少个空格 多少个* 

一共5 行              空格的个数(5-i)     *的个数 (2 *  i  -  1)

i=1                  4                               1  

i=2                   3                               3

i=3                  2                                5

i=4                 1                                 7  

i=5                 0                                 9
System.out.println("打印正三角形");
            for(int i=1;i<=5;i++){
                // 先打印空格
                for(int k=0;k<5-i;k++){
                    System.out.print("  ");
                }
                // 再打印*
                for(int j=0;j<2*i-1;j++){
                    System.out.print("* ");
                }
                // 换行
                System.out.println();
            }

 

十、数组

 

1、数组定义 

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

2、 数组特点

  • 数组的长度固定(数组的长度一旦声明,就不能改变)

  • 数组中存储的元素数据类型必须相同

  • 数组的元素 通过下标访问,且下标默认从0 开始

  • 数组类型属于引用数据类型, 数组的元素类型 既可以是基本数据类型,也可以是引用数据类型。

3、创建数组

  • 方式一
数组存储的数据类型 [] 数组名  = new 数组存储的数据类型[长度];

详解:

数组存储的数据类型 :创建数组容器中可以存储什么数据类型 (基本数据类型 ,引用数据类型)

[] : 表示数组

数组名: 给数组起给名字,遵循标识符规则

new : 创建数组的关键字

[长度] : 数组的长度 , 这个长度定义后不可改变

例如

int [] arr = new int[3];
  • 方式二
 数据类型 [] 数组名 = new 数据类型[]{元素1,元素2,元素3...}

这里的数组长度根据元素的个数自动分配大小

int [] arr = new int[]{90,88,78,92};
或者
int arr [] = new int[]{90,88,78,92}
  • 方式三
数据类型 [] 数组名  = {元素1,元素2,元素3...};

注意: 这里的元素类型必须满足 数组的元素数据类型

 char [] arr = {'a','b','c'};
 或者
 char arr [] = {'a','b','c'};

4、数组的访问

数组的访问通过索引访问

索引(下标): 每一个数组的元素都有一个编号,这个编号从0开始 , 这个编号称为数组的索引,通过数据名[索引] 访问到数组的原始

例如: 访问数组的第二个元素: 数组名[1]

数组的长度: 数组的长度 声明已固定 ,访问数组的长度 : 数组名.length

数组的最大索引= 数组的长度 -1

数组元素的赋值 :通过索引可以给元素赋值 数组名[索引] = 值

将数据 赋值给 指定索引的 元素

总结:

这周学的时Java基础,比较入门的知识,相对来说比较简单一点,就是有关循环的一些练习需要多做,要有一个好的逻辑思维。

1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。
1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值