Java第三天

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量303 收藏
点赞数
分类专栏： 学习 文章标签： java 算法 intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaban_/article/details/123057919
版权

Java第三天

算术运算符的使用(ArithmeticOperator.java)

  1. +，-，*，/，%，++，–

    public class ArithmeticOperator{

	public static void main(String[] args){

		System.out.println(10 / 4);//2
		System.out.println(10.0 / 4);//2.5

		double d = 10/4;
		System.out.println(d);//2.0

		//取模的本质 a % b = a - a/b * b
        //当a % b的a是小数时，公式为 a % b = a - (int)a/b * b
		System.out.println(10 % 3);//1
		System.out.println(-10 % 3);//-1
		System.out.println(10 % -3);//1
		System.out.println(-10 % -3);//-1

	}
}

  2. 自增：++
    作为独立的语句使用：
    ++i和i++都完全等价于i = i + 1；
    作为表达式使用：
    前++：++i先自增后赋值
    后++：i++先赋值后自增

    public class ArithmeticOperatorExercise01{

	public static void main(String[] args){
		int i = 1;
		i = i++;//规则使用临时变量：(1) temp = i;(2) i = i+1;(3)i = temp;
		System.out.println(i);//1

		int i = 1;
		i = ++i;//规则使用临时变量：(1) i = i+1;(2) temp = i;(3)i = temp;
		System.out.println(i);//2

	}
}

关系运算符的使用(RelationalOperator.java)

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

        int a = 9;
        int b = 8;
        System.out.println(a > b);//T
        System.out.println(a >= b);//T
        System.out.println(a <= b);//F
        System.out.println(a < b);//F
        System.out.println(a == b);//F
        System.out.println(a != b);//T
        boolean flag = a > b;//T
        System.out.println("flag = " + flag);
    }
}

逻辑运算符

  1. 短路与&&，短路或||，取反(非)!
  2. 逻辑与&，逻辑或|，逻辑异或^
    在这里插入图片描述

文字概述：

  1. a&b：&叫逻辑与：规则：当a和b同时为true，则结果为true，否则为false
  2. a&&b：&&叫短路与：规则：当a和b同时为true，则结果为true，否则为false
  3. a|b：|叫逻辑或：规则：当a和b有一个为true，则结果为true，否则为false
  4. a&b：||叫短路或：规则：当a和b有一个为true，则结果为true，否则为false
  5. !b：!叫取反：规则：当a为true，则结果为false，当a为false，结果为true
  6. ab：叫逻辑异或：规则：当a和b不同时，则结果为true，否则为false

&&和&的使用和区别(LogicOperator01.java)

public class LogicOperator01{

	public static void main(String[] args){

		int age = 50;
		if(age > 20 && age < 90){
			System.out.println("ok1");
		}

		if(age > 20 & age < 90){
			System.out.println("ok2");
		}
	}
}
区别：
  1. **&&短路与：**如果第一个条件为false，则第二个条件不会判断，最终结果为false，效率高
  2. **&逻辑与：**不管第一个条件是否为false，第二个条件都要判断，效率低
  3. 开发中，我们使用的基本是短语与&&，效率高
int a = 4;
int b = 9;
if(a < 1 && ++b < 50){
	System.out.println("ok3");
}
System.out.println("b = " + b);//b = 9

int a = 4;
int b = 9;
if(a < 1 & ++b < 50){
	System.out.println("ok4");
}
System.out.println("b = " + b);//b = 10

||和|的使用和区别和 &&、&类似

赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量

赋值运算符分为 基本赋值运算符 和 复合赋值运算符

复合赋值运算符：

+=，-=，*=，/=，%=等

注意：

  1. 运算顺序从右往左 int num = a + b + c；
    这句话的意思是先计算a+b+c再进行赋值给num，a+b+c的计算还是遵循数学的计算规则

  2. 赋值运算符的左边 只能是变量，右边可以是变量，表达式，常量值
    int num = 20；int num2 = 78*34 - 10；int num3 = a；

  3. 复合赋值运算符等价于下面的效果，比如：
    a += 3； 等价于 a = a + 3；

  4. 复合赋值运算符会进行类型转换(AssignOperator.java)。

    public class AssignOperator{

	public static void main(String[] args){
		byte b = 3;
		b += 2;//等价于 b = (byte)(b + 2);
	}
}

三元运算符

基本语法

条件表达式 ? 表达式1:表达式2;

运算规则
  1. 如果条件表达式为true，运算后的结果是表达式1；
  2. 如果条件表达式为false，运算后的结果是表达式2；
public class TernaryOperator{

	public static void main(String[] args){

		int a = 10;
		int b = 99;
		//1.a > b 为false
		//2.返回 b--，先返回b的值，然后再运算
		//3.返回结果是99
		int result = a > b ? a++ : b--;//99
		System.out.println("result = "+result);		
	}
}
使用细节(TernaryOperatorDetail.java)

  1. 表达式1和表达式2要为可以赋给接收变量的类型(或可以自动转换)

    public class TernaryOperatorDetail{
	public static void main(String[] args){
		int a = 3;
		int b = 8;
		int c = a > b ? (int)1.1 : (int)3.4;//ok
		//int c = a > b ? 1.1 : 3.4;//错误，1.1和3.4是double类型
		double d =  a > b ? 1.1 : 3.4;//ok
	}
}

  2. 三元运算符可以转成if – else语句

运算符优先级

  1. . () {} ; ,
  2. 弹幕运算符 ++ – ~ !{data type}
  3. 算术运算符 * / % + -
  4. 位移运算符 << >> >>>
  5. 比较运算符 < > <= >= instanceof
  6. 逻辑运算符 == != & ^ | && ||
  7. 三元运算符 ? :
  8. 赋值运算符 = *= /= %= += -= <<= >>= >>>= &= ^= |=

标识符的命名规则和规范

标识符概念

  1. Java对各种变量、方法和类等命名时使用的字符序列称为标识符
  2. 凡是自己可以起名字的地方都叫标识符

标识符的命名规则

  1. 由26个英文字母大小写，0-9，_或$组成
  2. 数字不可以开头
  3. 不可以使用关键字和保留字，但能包含关键字和保留字
  4. Java中严格区分大小写，长度无限制。
  5. 标识符不难包含空格

标识符命名规范

  1. 包名：多单词组成时所有字母都小写：aaa.bbb.ccc
  2. 类名，接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz[大驼峰]
    比如：TankShotGame
  3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz[小驼峰，简称 驼峰法]
    比如：tankShotGame
  4. 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
    比如：定义一个所得税率 TAX_RATE

键盘输入语句

在编程中，需要接受用户输入的数据，就可以使用键盘输入语句来获取。需要一个扫描器(对象)，就是Scanner

步骤：

  1. 导入该类的所在包，java.util.xxx
  2. 创建该类对象(声明变量)
  3. 调用里面的功能
import java.util.Scanner;//表示把java.util下的Scanner类导入
public class Input{
	public static void main(String[] args){
		//Scanner类表示 简单文本扫描器，在java.util包
		//1.引入/导入 Scanner类所在的包
		//2.创建 Scanner 对象 ，new创建一个对象
		Scanner myScanner = new Scanner(System.in);
		//3.接受用户的输入，使用相关的方法
		System.out.println("请输入名字");
		String name = myScanner.next();//接收用户输入的字符串
		System.out.println("请输入年龄");
		int age = myScanner.nextInt();//接受用户输入的int
		System.out.println("请输入薪水");
		double money = myScanner.nextDouble();//接受用户输入的double
		
		System.out.println("人的信息如下：");
		System.out.println("名字：" + name + "年龄：" + age + "薪水：" + money);

	}
}

进制

对于整数，有四种表示方式：

  1. 二进制：0，1，满2进1，以0b或者0B开头
  2. 八进制：0-7，满8进1，以数字0开头表示
  3. 十进制：0-9，满10进1
  4. 十六进制：0-9及A(10)-F(15)，满16进1，以0x或者0X开头表示。A-F不区分大小写
int n1 = 0b1010;
int n2 = 01010;
int n3 = 1010;
int n4 = 0x1010;
System.out.println("n1 = "+ n1);//10
System.out.println("n2 = "+ n2);//520
System.out.println("n3 = "+ n3);//1010
System.out.println("n4 = "+ n4);//4112

进制转换

  1. 二进制转十进制：
    规则：从最低位(右边)开始，奖每个位上的数提取出来，乘以2的(位数-1)次方，然后求和
    例子：0b1011 = 1*2^0 + 1*2^1 + 0*2^2 + 1*2^3 = 1 + 2 + 0 + 8 = 11
  2. 八进制转十进制：
    规则：从最低位(右边)开始，奖每个位上的数提取出来，乘以8的(位数-1)次方，然后求和
    例子：0234 = 4*8^0 + 3*8^1 + 2*8^2 = 4 + 24 + 128 = 156
  3. 十六进制转十进制：
    规则：从最低位(右边)开始，奖每个位上的数提取出来，乘以16的(位数-1)次方，然后求和
    例子：0x23A = 10*16^0 + 3*16^1 + 2*16^2 = 10 + 48 + 512 = 570
  4. 十进制转换成二进制
    规则：将该数不断除以2，直到商为0未知，然后将每步得到的余数倒过来，就是对应的二进制
    例子：
    34：34%2 = 0 17%2 = 1 8%2 = 0 4%2 = 0 2%2 = 0 1%2 = 1
    所以十进制的34对应二进制的0010 0010
  5. 十进制转换成八进制
    规则：将该数不断除以8，直到商为0未知，然后将每步得到的余数倒过来，就是对应的八进制
    例子：
    131：131%8 = 3 16%8 = 0 2%8 = 2
    所以十进制的131对应八进制的203
  6. 十进制转换成十六进制
    规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的十六进制
    例子：
    237：**237%16 = 13(D) 14%16 = 14(E) **
    所以十进制的237对应十六进制的ED
  7. 二进制转成八进制
    规则：从低位开始，将二进制数每三位一组，转成对应的八进制即可
    例子：
    0b11(3)010(2)101(5) => 0325
  8. 二进制转成十六进制
    规则：从低位开始，将二进制数每四位一组，转成对应的十六进制即可
    例子：
    0b1101(D)0101(5) =>0xD5
  9. 八进制转成二进制
    规则：将八进制的每一位转成对应一个3位的二进制数即可
    例子：
    02(010)3(011)7(111) => 0b10011111
  10. 十六进制转成二进制
    规则：将十六进制的每一位转成对应一个4位的二进制数即可
    例子：
    0x2(0010)3(0011)B(1011) => 0b001000111011

原码、反码、补码

对于有符号的而言：

  1. 二进制的最高位是符号位：0表示正数，1表示负数
  2. 正数的原码、反码、补码都一样
  3. 负数的反码 = 它的原码符号位不变，其它位取反
  4. 负数的补码 = 它的反码+1 负数的反码 = 负数的补码 - 1
  5. 0的反码、补码都是0
  6. java没有无符号数，换而言之，java中的数都是由符号的
  7. 在计算机运算的时候，都是以补码的方式来运算的
  8. 当我们看运算结果的时候，要看它的原码

位运算符

java中由7个位运算符(&、|、^、~、>>、<<和>>>)

分别是按位与&、按位或|、按位异或^、按位取反~
运算规则：

按位与& ： 俩位全为1，结果为1，否则为0
例子：0b10010001 & 0b11110010 = 0b10010000

按位非| ： 俩位由一个为1，结果为1，否则为0
例子：0b10010001 | 0b11110010 = 0b11110011

按位异或^ ： 俩位一个为0，一个为1，结果为1，否则为0

例子：0b10010001&0b11110010 = 0b01100011

按位取反~ ： 0 -> 1 , 1 -> 0

例子 ~0b10010001 = 0b01101110

运算试题

public class aaa{

	public static void main(String[] args) {
		//2&3
		//1.先得到2的补码 => 2的原码00000000 00000000 00000000 00000010
		//   2的补码 = 2的原码 = 00000000 00000000 00000000 00000010
		//2.3的补码 = 3的原码 = 00000000 00000000 00000000 00000011
		//3.按位与&
		//  00000000 00000000 00000000 00000010
		//  00000000 00000000 00000000 00000011
		//  00000000 00000000 00000000 00000010 &运算后的补码
		// 运算后的原码也是00000000 00000000 00000000 00000010
		// 结果就是 2
		System.out.println(2&3);//2

		//1. 先得到 -2的原码 10000000 00000000 00000000 00000010
		//2. 再得到 -2的反码 11111111 11111111 11111111 11111101
		//3. 再得到 -2的补码 11111111 11111111 11111111 11111110 
		//4. ~-2操作        00000000 00000000 00000000 00000001 运算后的补码
		//5. 运算后的原码    00000000 00000000 00000000 00000001 => 1
		System.out.println(~-2);//1

		//1.先得到   2的原码 00000000 00000000 00000000 00000010
		//2.再得到   2的补码 00000000 00000000 00000000 00000010
		//3.~2操作		  11111111 11111111 11111111 11111101 运算后的补码
		//4.运算后的反码     11111111 11111111 11111111 11111100
		//5.运算后的原码     10000000 00000000 00000000 00000011 => -3
		System.out.println(~2);//-3
        
        //1.先得到 2的原码   00000000 00000000 00000000 00000010
		//2.再得到 2的补码   00000000 00000000 00000000 00000010
		//3.在得到 3的原码   00000000 00000000 00000000 00000011
		//4.在得到 3的补码   00000000 00000000 00000000 00000011
		//5.操作2|3 		  00000000 00000000 00000000 00000010
		// 				   00000000 00000000 00000000 00000011
		//在得到			 00000000 00000000 00000000 00000011 运算后的补码
		//所以运算后的原码是  00000000 00000000 00000000 00000011 =>3
		System.out.println(2|3);//3

		//1.先得到 2的原码   00000000 00000000 00000000 00000010
		//2.再得到 2的补码   00000000 00000000 00000000 00000010
		//3.在得到 3的原码   00000000 00000000 00000000 00000011
		//4.在得到 3的补码   00000000 00000000 00000000 00000011
		//5.操作2^3 		  00000000 00000000 00000000 00000010
		// 				   00000000 00000000 00000000 00000011
		//在得到			 00000000 00000000 00000000 00000001 运算后的补码
		//所以运算后的原码是  00000000 00000000 00000000 00000001 =>1
		System.out.println(2^3);//1
	}
}

关于>>、<<和>>>的运算规则：

  1. 算术右移 >>：低位溢出，符号位不变，并用符号位补溢出的高位
  2. 算术左移 <<：符号位不变，低位补0
  3. >>>逻辑右移也叫无符号右移，运算规则是：低位溢出，高位补0
  4. 特别说明：没有<<<符号

应用案例(BitOperator02.java)

public class BitOperator02{
	public static void main(String[] args) {
		int a = 1 >> 2;
		//1 => 	00000000 00000000 00000000 00000001
		//	=>	00000000 00000000 00000000 00000000
		//本质1 / 2 / 2 = 0
		int c = 1 << 2;
		// 1 => 00000000 00000000 00000000 00000001
		//   => 00000000 00000000 00000000 00000100
		//本质1 * 2 * 2 = 4
		System.out.println(1 >> 2);//0
		System.out.println(1 << 2);//4
		System.out.println(4 << 3);//4 * 2 * 2 * 2 = 32
		System.out.println(15 >> 2);//15 / 2 / 2 = 3

	}
}

程序控制结构

顺序控制

程序从上到下逐行地执行，中间没有人和判断和跳转

分支控制if-else

  1. 单分支
    基本语法
    if(条件表达式){
    ​ 执行代码块；
    }
    当条件表达式为true时，就会执行{}的代码。如果为false就不执行

  2. 双分支
    if(条件表达式){
    ​ 执行代码块1；
    }else{
    ​ 执行代码块2；
    }

    当条件表达式为true时，就会执行代码块1，如果为false就执行代码块2

    public class IfExercise01{
	public static void main(String[] args) {
		double d1 = 12.5;
		double d2 = 15.3;

		if(d1 > 10.0 && d2 < 20.0){
			System.out.println(d1 + d2);
		}

		int a = 15;
		int b = 15;

		if((a+b) % 3 == 0 && (a+b) % 5 == 0){
			System.out.println("yes");
		}else{
			System.out.println("no");
		}

		int years = 2000;
		if((years % 4 == 0 && years % 100 != 0) || years % 400 == 0){
			System.out.println("是闰年");
		}else{
			System.out.println("不是闰年");
		}
	}
}

  3. 多分支

    if(条件表达式1){
    ​ 执行代码块1；
    }else if(条件表达式2){
    ​ 执行代码块2；
    }…
    else{
    ​ 执行代码块n；
    }

    当条件表达式1为true时，就会执行代码块1，如果为false就会看条件表达式2，如果为true，则执行代码块2，以此类推…如果条件表达式都为false，则输出代码块n
    特别说明：

    1. 多分支可以没有else，如果所有条件表达式都不成立，则一个执行入口都没有
    2. 多分支控制最多只能有一个执行入口

嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构成为内层分支，外面的分支结构称为外层分支
嵌套分支不要超过3层(可读性不好)

基本语法
if(){
​ if(){
​ //if-else…
​ }else{
​ //if-else
​ }
}

import java.util.Scanner;
public class Nestedlf{
	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		
		System.out.print("请输入该歌手的成绩：");
		double score = scanner.nextDouble();

		
	
		if(score > 8.0){
			
			System.out.print("请输入该歌手的性别：");
			char gender = scanner.next().charAt(0);
			
			if(gender == '男'){
				System.out.println("你成功进入男子决赛");
			}else if(gender == '女'){
				System.out.print("你成功进入女子决赛");
			}else{
				System.out.print("你成功进入无性别组决赛");
			}

		}else{
			System.out.print("你没有进入决赛");
		}
	}
}
xiaban_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
零基础学习Java第三天
09-28
零基础学习Java第三天
表达式
ztj6_2的博客
04-23 136
1.bool类型 bool只有true和false 在C语言环境中只有0才为false，其他情况（非0）都为true 2.关系表达式 ：运算结果是bool值 3.逻辑表达式 ：运算结果是bool值 1、与运算（&&） 参与运算的两个表达式都为真结果才为真，只要有一个为假就是假。 由此可得简洁与（截断与）概念： 与运算中，前面的表达式为假时，结果即为假，后面的表达式不参与运算。 2、或运算（||） 参与运算的的两个表达式只要有一个为真，结果就为真。 由此可得简洁或（截断或）概念： 或运算中
Java运算符（Operator）之 算数运算符（ArithmeticOperator）
A_Zeng_的博客
12-09 719
算数运算符（ArithmeticOperator） 概述： Java中使用数据进行数学运算时使用的符号，大部分符号都有自己的算数功能 分类： 普通的算数运算 + ： 1、表示正数 2、表示加法运算 3、遇到了字符串数据表示拼接字符串 - ： 1、表示负数 2、表示减法运算 ** *：**表示乘法运算 **/ ：**表示出发运算 **% ：**表示模运算（取数） ...
Java学习第三天
03-14
Java学习来到了第三天，希望大家好好学习
java培训第十三天笔记.pdf
11-30
"Java培训第十三天笔记" Java培训第十三天笔记是Java语言的学习笔记，涵盖了Java语言的基本概念、语法和常见应用场景。在本节笔记中，我们将学习Java语言的基本数据类型、变量、运算符、控制结构、函数和数组等内容...
自学Java第三天 day03.java
08-30
自学Java第三天 day03.java
学习Java第三天练习代码Day3.rar
02-08
学习java第三天练习的代码，包含基本数据类型float、double、boolean、char、转义字符、String、类型转换、表达式、运算符
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 407
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 788
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 774
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 141
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 326
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1889
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 974
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 826
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 655
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
javaScrip的学习（一）
weixin_65450681的博客
07-19 1310
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
Java入门指南：21天掌握Java编程
3. JavaME（Java Micro Edition）：微型版，主要针对嵌入式和移动设备开发，如手机应用。 为了开始Java学习之旅，书中详细讲解了如何搭建Java开发环境。第一步是安装Java Development Kit (JDK)，它是编写、编译和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值