2021-03-25

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量157 收藏
点赞数 1
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46537166/article/details/115212567
版权

文章目录

Java入门阶段

Java的核心优势

跨平台是java语言的核心优势，赶上最初互联网的发展，建立了强大的生态体系，目前覆盖IT各行业的 “第一大语言”，

是计算机界的“英语”。

Java三大版本含义

  • JavaSE(Java Standard Edition)：标准版，定位在个人计算机上的应用(桌面系统)。

  • JavaEE(Java Enterprise Edition) ：企业版，定位在服务器端的应用。

  • JavaME(Java Micro Edition)：微型版，定位在消费性电子产品的应用。

Java的特性和优势

  • 跨平台/可移植性

    这是Java的核心优势，Java在设计时就很注意移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16,32，可能是根据编译器厂商规定的变化。这样的话程序的移植就会非常麻烦。

  • 安全性

    Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入很大的精力，是Java可以很容易构建防病毒，防篡改的系统。

  • 面向对象

    面向对象是一种程序技术，非常适合大型软件的设计和开发。由于 C++ 为了照顾大量C语言使用者而兼容了C，使得自身仅仅成为了带类的C语言，多少影响了其面向对象的彻底性！Java则是完全的面向对象语言。

  • 简单性

    Java就是C++的简化版，我们也可以将Java称之为"C+±"(C加加减)，指的就是将C++的一些内容去掉；比如：头文件，指针运算，结构，联合，操作符重载，虚基类等等。同时，由于语法基于C语言，因此学习起来完全不费力。

  • 高性能

    Java最初发展阶段，总是被人诟病 ”性能低“；客观上，高级语言运行效率总是低于低级语言的，这个无法避免。Java语言本身发展中通过虚拟机的优化提高了几十倍的运行效率。比如，通过JIT（JUST IN TIME）即时编译技术提高运行效率。将一些"热点"字节码编译成本地机器码，并将结果缓存起来，在需要时重新调用。这样的话，使Java的程序的执行效率大大提高，某些代码甚至接待C++的效率。

    因此，Java低性能的短板，已经被完全解决了。业界发展上，我们也看到很多C++应用转到Java

    开发，很多++程序员转型为Java程序员。

  • 分布式

    Java是为Internet的分布式环境设计的，因为它能处理TCP/IP协议。事实上，通过URL访问一个

    网络资源和访问本地文件一样简单的。Java还支持远程方法调用(RMI,Remote,Method Invocation),

    使程序能够通过网络调用方法。

  • 多线程

    多线程的使用可以带来更好的交互响应和实时行为。Java多线程的简单性是Java成为主流服务器

    端开发语言的主要原因之一。

  • 健壮性

    Java是一种健壮的语言，吸收了C/C + + 语言的特点，但去掉了其影响程序健壮的部分分（如：

    指针、内存的申请与释放等)。Java程序不可能造成计算机崩溃。即使Java程序也可能错误。如果

    出现某种出乎意料的事，程序也不会崩溃，而是把异常抛出，在通过异常处理机制加以处理。

Java应用程序的运行机制

计算机高级语言的类型主要有编译型和解释型两种，而Java语言是两种类型的结合。
Java首先利用文本编辑器编写Java源程序，源文件的后缀名为.java; 再利用编译器（javac）
将源程序编译成字节码文件，字节码文件的后缀名为.class; 最后利用虚拟机(解释器，java)解释执行。

在这里插入图片描述

JVM、JRE和JDK

JVM（Java Virtual Machine）就是一个虚拟的用于执行bytecode字节码的”虚拟计算机“。他也

定义了指令集、寄存器集、结构栈、垃圾收集堆、内存区域。JVM负责字节码解释运行，边解释

边运行，这样，速度就会受到一定的影响。

不同的操作系统有不同虚拟机。Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，随处执行”。

Java虚拟机是实现跨平台的核心机制。

在这里插入图片描述

JRE（Java Runtime Environment）包含：Java虚拟机、库函数、运行Java应用程序所必须的文件。

JDK（Java Development Kit）包含：JRE，以及增加编译器和调试器等用于程序开发的文件。

在这里插入图片描述

  • 如果只是要运行Java程序，只需要JRE就可以。JRE通常非常小，其中包含了JVM。
  • 如果要开发Java程序，就需要按照JDK。

Java程序详细解析

1、Java对大小写敏感，如果出现了大小写拼写错误，程序无法运行。

2、关键字public被称作访问修饰符（access modifier），用于控制程序其它部分对这段代码的访问级别。

3、关键字class的意思是类。Java是面向对象的语言，所有代码必须位于类里面。

4、一个源文件中至多只能声明一个public的类，其它类的个数不限，如果源文件中包含一个public

类，源文件名必须和其中定义的public的类名相同，且以 “.java” 为扩展名。

5、一个源文件可以包含多个类class。

6、正确编译后的源文件，会得到相应的字节码文件，编译器为每个类生成独立的字节码文件，且将字节

码文件自动命名为类的名字且以 “.class” 为扩展名。

7、main方法是Java应用程序的入口方法，它有固定得书写格式：

8、public static void main（String[] args）{…}

9、在Java中，用花括号划分程序的各个部分，任何方法的代码都必须以 “{” 开始，以 “}” 结束，由于

编辑器忽略空格，所以花括号风格不受限制。

10、Java中每个语句必须以分号结束，回车不是语句的结束标志，所以一个语句可以跨多行。

  • 编程时，一定要注意缩进规范；
  • 在写括号、引号时，一定是成对编写，然后在往里插入内容。

常用的DOS命令

cd 目录路径 进入下一个目录

cd … 进入父级目录

dir 查看本目录下的文件和子目录列表

cls 清除屏幕命令

上下键 查找敲过的命令

Tab键 自动补齐命令

注释

在这里插入图片描述

标识符

标识符是用来给变量、类、方法以及包进行命名的，如Welcome、main、System、age、

name、gender等。表示符需要遵守一些规则：

  • 标识符必须以字母、下划线、美元符号$开头。
  • 标识符其他部分可以是字母、下划线 ”_“、美元符 ”$“ 和数字的任意组合。
  • Java标识符大小写敏感，且长度无限制。
  • 标识符不可以是Java的关键字。

标识符的规范

  • 表示类名的标识符：每个单词的首字母大写，如：Man、GoodMan

  • 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“‘驼峰原则’， 如：eat()，eatFood()

【注意】：java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的国际字符集。 因此，这里字母的含义不仅仅是英文，还包括汉字等。但是不建议大家使用汉字来定义标识符！

【示例】 合法的表示符

int  a =  3;

int  _123  = 3;

int  $12aa  = 3;

int  变量1  = 6；  //合法，但不建议使用中文命名的标识符

【示例】 不合法的标识符

int   1a  = 2;         //不能用数字开头

int    a#  = 2;       //不能包含#这样的特殊字符

int   int   =  4；   //不能使用关键字

Java中的关键字保留字

Java关键字是Java语言保留提供内部使用的，如class用于定义类。关键字也可以称为保留字，它们意思

是一样的，我们不能使用关键字作为变量名或方法名。

在这里插入图片描述

变量的本质

变量本质上就是代表一个 “可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确

定。我们可通过变量名来访问 “对应的存储空间”，从而操纵这个“存储空间” 存储的值。

Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空

间的大小。比如，int a = 3; 表示a变量的空间大小为4个字节。

变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明，只有在变量声明以后，才能为其分配相应长度的存储空间。

变量的声明

格式为：

type varName [=value] [,varName[=valye]...]; 
//[]中的内容为可选项，及可有可无
数据类型    变量名    [=初始值]   [,变量名  [=初始值]...];

【实例 】声明变量：

double  salary;

long   earthPopulation;

int   age;

不同的数据类型的常量会在内存中分配不同的空间，如图所示：

在这里插入图片描述

注意事项

  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

[示例] 在一行中声明多个变量

int i , j ; //两个变量的数据类型都是int

不提倡这种 “一行中声明多个变量” 风格，逐一声明每个变量可以提高程序的可读性。

【示例】可以将变量的声明和初始化放在同一行中

int age = 18;
double e = 2.122;

变量分类

  • 局部变量（local variable）

    方法或语句块内部定义的变量。生命周期是从声明位置开始到方法或语句块执行完毕为止。局部

    变量在使用前必须先声明、初始化（赋初值）再使用。

【示例】局部变量

public void test(){
    int i;
    int j = i+5; //编译出错，变量i还未被初始化
}

public void test(){
    int i;
    i = 10;
    int j = i+5; //编译正确 
}

  • 成员变量（也叫实例变量 member variable）

    方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会

    自动初始化成该类型的默认初始值。

实例变量的默认初始值
数据类型实始值
int0
double0.0
char’\u0000‘
booleanfalse

实例变量的声明

public class Test{
	int i;
}

  • 静态变量（类变量 static variable)

    使用static定义。从属于类，生命周期伴随类始终，从类加载到卸载。

    如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值，

    如图所示：

    变量的声明与赋值

    public class LocalVariableTest{
    public static void main(String[] args){
     	boolean flag = true;   //声明boolean型变量并赋值
        char c1, c2;   //声明char型变量
        c1 = '\u0041'; //为char型变量赋值
        c2 = 'B';  //为char型变量赋值
        int x;  //声明int型变量
        x = 9;  //为int型变量赋值
        int y  = x;  //声明并初始化int型变量
        float f = 3.15f; //声明float型变量并赋值
        double d = 3.14152926; //声明double型变量并赋值
    }
}

    常量(Constant）

    常量通常指的是一个固定的值，例如：1、2、3、‘a’、’b‘、true 、false、“helloWorld”等。

    在Java语言中，主要是利用关键字final来定义一个常量。常量一旦被初始化后不能再更改其值。

声明格式为：

final type varName = value;

常量的声明及使用：

public class TestConstants{
    public static void main(String[] args){
        final double PI = 3.14;
        //PI = 3.15;//编译错误，不能再被赋值！
        double r = 4;
        double area = PI * r * r;
        double circle = 2 * PI * r;
        System.out.println("area = " + area);
        System.out.println("circle = " + circle);	
    }
}

基本数据类型(primitive data type)

Java是一种强类型语言，每个变量都必须声明其数据类型。Java的数据类型可分为两大类：基本数据类型(primitive data type)和引用数据类型(reference data type)。

Java中定义了3类8种基本数据类型

  • 数值型 —— byte、short、int、long、float、double
  • 字符型（文本型）—— char
  • 布尔型 —— boolean
    在这里插入图片描述

整型变量/常量

整型用于表示没有小数部分的数值，它允许是负数。整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。与此相反，C和C + +程序需要针对不同的处理器选择最有效的整型。

整型数据类型
类型占用储存空间表数范围
byte1字节在这里插入图片描述
short2字节在这里插入图片描述
int4字节在这里插入图片描述
long8字节在这里插入图片描述

Java语言整型常量的四种表示方式

  • 十进制整数，如：99，-500，0
  • 八进制整数，要求以0开头，如：015
  • 十六进制数，要求以0x 或 0X开头，如：0x15
  • 二进制数，要求0b或0B开头，如：0b01110011

Java语言的整型常数默认为int型，声明long型常量可以后加 “l” 或 “L”。

浮点型变量/常量

带小数的数据在Java中称为浮点型。浮点型可分为float类型和double类型。

浮点型数据类型
类型占用储存空间表数范围
float4字节-3.403E38 ~ 3.403E38
double8字节-1.798E308 ~ 1.798E308

float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度

很难满足需求。而double表示这种类型的数值精度约是float类 型的两倍，又被称双精度类型，绝大多部分应用程序都采用double类型。浮点型常量默认类型也是double。

java浮点类型常量有两种表示形式

  • 十进制数形式，例如：3.14 314.0 0.314
  • 科学记数法形式，如：314e2 314E2 314E-2

[示例] 使用科学记数法给浮点型变量赋值

double f = 314e2; //314*10^2-->31400.0
double f2 = 314e-2; //314*10^(-2)-->3.14

float类型的数值有一个后缀F或f，没有后缀F或f的浮点数值默认为double类型。也可以在浮点

数值后添加后缀D或d，以明确其为double类型。

字符型变量/常量

字符型在内存中占2个字节，在Java中使用单引号来表示字符常量。例如：’ A ‘ 是一个字符，

它与 “ A ”是不同的，“ A ”表示含有一个字符的字符串。

char类型用来表示在Unicode编码表中的字符。Unicode编程被设计用来处理各种语言文字，

它占2个字节，可允许有65536个字符。

字符型举例：

char eChar = 'a';
char eChar = '中';

Unicode具有从0到65535之间的编码，他们通常从’ \u0000‘ 到 ’ \uFFFF ‘ 之间的十六进制值来表示（前缀为u表示Unicode）

字符型的十六进制值表示方法

char c = '\u0061';

Java语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其他的含义。常用的转义字符及其含义和Unicode值如表：

char c ='\n';  //代表换行符
转义字符
转义符含义Unicode值
\b退格（backspace）\u0008
\n换行\u000a
\r回车\u000d
\t制表符号(tab)\u0009
\ "双引号\u0022
\ ’单引号\u0027
\反斜杠\u005c

boolean的变量/常量

boolean类型有两个常量值，true和false，在内存中占一位(不是一个字节)，不可以使用0或非0的整数代替true和false，

这点和C语言不同。boolean类型用来判断逻辑条件，一般用于程序流程控制。

boolean类型

boolean flag;
flag = true;  //或者flag=false
if(flag){
    //true分支
}else{
    //false分支
}

摘自老鸟

请不要这样写：if(flag == true),只有新手才那么写。关键也容易写错成if(flag=true), 这样就变赋值flag 为true而不是判断。

if（flag）或者if（！flag）

运算符（operator）

计算机的最基本用途之一就是执行数学计算，作为一门计算语言，Java也提供了一套丰富的运算

符操作变量。

运算符分类

  • 算数运算符

    • 二元运算符：+，-，*，/，%
    • 一元运算符：++，–

  • 赋值运算符：=

  • 扩展运算符：+=，-=，*=，/=

  • 关系运算符：>，<，>=，<=，==，!=，instanceof

  • 逻辑运算符：&&，||，！，^

  • 位运算符：&，|，^，~，>>，<<，>>>

  • 条件运算符：? ：

  • 字符串连接符：+

算数运算符

算数运算符中+，-，*，/，%属于二元运算符，二元运算符指的是需要两个操作数才能完成运算的运算符。其中的%是取模运算符，就是我们常说的求余数操作。

二元运算符的运算规则

整数运算：

  1. 如果两个操作数有一个为Long，则结果也为Long。
  2. 没有long时，结果为int。即使操作数全为short，byte结果也是int。

浮点运算：

3.如果两个操作数有一个为double，则结果为double。

4.只有两个操作数都为float，则结果才为float。

取模运算:

  1. 其操作可以为浮点数，一般使用整数，结果是"余数"，”余数“符号和左边操作数相同，如：

7%3=1，-7%3=-1，7%-3=1。

算术运算符中++，–属于一元运算符，该运算符只需要一个操作数。

一元运算符++与- -

int a = 3;
int b = a++;//执行完后，b=3.先给b赋值，再自增。
System.out.println("a="+a+"\nb"+b);
a = 3;
b = ++a; //执行完后，a=5，a先自增，再给c赋值
System.out.println("a="+a+"\nc"+b);

运行结果为：

a=4
b=3
a=4
b=4

赋值及其扩展赋值运算符

在这里插入图片描述

【示例】扩展运算符

int a = 3;
int b = 4;
a += b;//相当于a=a+b;
System.out.println("a="+a+"\nb="+b);
a = 3;
a*b=3;//相当于a=a*(b+3);
System.out.println("a="+a+"\nb="+b);

运行该程序，执行结果:

a=7;
b=4;
a=21;
b=4;

关系运算符

关系运算符用来进行比较运算，如表：

在这里插入图片描述

！注意事项

  • =是赋值运算符，而真正的判断两个操作数是否相等的运算符是==
  • ==、!=是所有（基本和引用）数据类型都可以使用
  • >、=、<，<=仅针对数值类型（byte/short/int/long，float/double.。以及char）

逻辑运算符

逻辑运算的操作数结果都是boolean值。

在这里插入图片描述

短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该

逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。

【示例】短路与和逻辑与

//1>2的结果为false，那么整个表达式的结果即为false，将不再计算2>(3/0)
boolean c = 1>2 &&  2>(3/0);
System.out.println(c);
//1>2的结果为false，那么整个表达式的结果即为false，还要计算2>(3/0),0不能做除数，//会输出异常信息
boolean d = 1>2 & 2>(3/0);
System.out.println(d);

位运算符

位运算指的是进行二进制位的运算，常用的位运算符如表：

位运算符

位运算符说明
~取反
&按位与
|按位或
^按位异或
<<左移运算符，左移1位相当于乘2
>>右移运算符，右移1位相当于除2取商

【示例】左移运算符和右移运算符

int a = 3*2*2;
int b = 3<<2;//相当于：3*2*2;
int c = 12/2/2;
int d = 12>>2;//相当于12/2/2;

雷区

  1. &和|既是逻辑运算符，也是位于运算符。如果两侧操作数都是boolean类型，就作为逻辑运算符，如果两侧的操作数是整数类型，就是位于运算符。
  2. 不要把 “^” 当做数学运算 “乘方”，是 “位的异或” 操作。

字符串连接符

" + " 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换

为字符串然后再进行连接。

[示例] 连接符“ + ”

int a = 12;
System.out.println("a="+a);//输出结果为 a=12

条件运算符

语法格式

x ? y : z

其中 x 为boolean类型表达式，先计算x的值，若为true，则整个运算的结果为表达式y的值，

否则整个运算结果为z的值。

【示例】三目条件运算符

int score = 80;
int x = -100;
String type = score<60?("不及格":"及格");
int flag = x > 0 ? 1 :(x == 0 ? 0 : -1);
System.out.println("type=" + type);
System.out.println("flag=" + flag);

运算结果：

type = 及格
flag= -1

运算符优先级

在这里插入图片描述

逻辑非>逻辑与>逻辑或

自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量的数据类型。

在这里插入图片描述

可以将整型常量直接赋值给byte、short、char等类型变量，而不需要进行强制类型转换，只要

不超出其表数范围即可。

【示例】自动类型转换特例

short b = 12;//合法
short b = 1234567;//非法，1234567超出了short的表数范围

强制类型转换

强制类型转换，又称作造型，用于显示的转换一个数值的类型。在有可能丢失信息的情况下进行

的转换是通过造型来完成的，但可能造成精度降低和溢出。

语法格式：

(type)var

运算符 “()” 中的type表示将值var想要转换成的目标数据类型。

【示例】强制类型转换

double  x = 3.14;
int nx = (int)x;//值为3
char c = 'a';
int d = c+1;
System.out.println(nx);
System.out.println(d);
System.out.println((char)d);

运行结果：

3
98
b

基本类型常见错误

操作比较大的数时，要留意是否溢出，尤其是整数操作时。

int money = 1000000000;//10亿
int years = 20;
//返回的total是负数，超过了int的范围
int total = money*years;
System.out.println("total"+total);
//返回的total仍然是负数，默认是int，因此结果会转成int值，再转成long。但是已经发生//了数据丢失
long total1 = money*years;
System.out.println("total1"+total1);
//返回的total2正确：先将一个因子变成long，整个表达式发生提升。全部用long来计算。
long total2 = money*((long)years);
System.out.println("total2="+total2);

运行结果：

total=1474836480
total1=-1474836480
total2=20000000000

**不要命名名字为l的变量，l容易和1混淆。long类型使用大写L不要小写。 **

int l = 2;//分不清是L还是1.
long a = 23451l;//建议使用大写L
System.out.println(l+1);

使用Scanner获取键盘输入

package com.company.pojo;

import java.util.Scanner;

public class TestScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名字：");
        String name = scanner.nextLine();
        System.out.println("请输入你的爱好：");
        String favor = scanner.nextLine();
        System.out.println("请输入你的年龄：");
        int age = scanner.nextInt();

        System.out.println("#########");
        System.out.println(name);
        System.out.println(favor);
        System.out.println("来到地球的天数："+age*365);
        System.out.println("离开地球的天数："+(72-age)*365);
    }
}

运行结果：

请输入名字：
袁文博
请输入你的爱好：
吃吃吃
请输入你的年龄：
19
#########
袁文博
吃吃吃
来到地球的天数：6935
离开地球的天数：19345

控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句

  • “顺序结构” 代表 “先执行a，再执行b”的逻辑
  • “选择结构"代表”如果…，则…“的逻辑
  • “循环结构”代表“如果…，则再继续…"的逻辑

任何软件和程序，小到一个联系，大到一个操作系统，本质上都是由 “变量、选择语句、循环语句” 组成。选择

选择结构

if单选择结构
  • 语法结构：
if(布尔表达式){
    语句块
}

if语句对布尔表达式进行一次判定，如判定为真，则执行{}中的语句块，否则跳过该语句块，流程如图：

在这里插入图片描述

【示例】if单选择结构

public class Test1{
    public static void main(String[] args){
        //通过掷三个骰子看看看看今天的手气如何？
        int 
            
    }
}

Math类的使用

  1. Java.lang包中的Math类提供了一些用于数学计算的方法。

  2. Math.random()该方法用于产生一个1到0区间的double类型的随机数，但是不包括1。

    int i = (int)(6*Math.random());产生：[0,5]之间的随机整数

    class TestIf {
    public static void main(String[] args) {
        //通过掷三个骰子看看今天手气如何？
        int i = (int)(6*Math.random())+1;//通过Math.random()产生随机数
        int j = (int)(6*Math.random())+1;
        int k = (int)(6*Math.random())+1;
        int count  = i + j + k;
        //如果三个骰子之和大于15，则手气不错
        if(count >15){
            System.out.println("今天手气不错");
        }
        //如果三个骰子之和在10到15之间，则手气一般
        if(count >=10 && count <= 15){
            System.out.println("今天手气一般");
        }
        //如果三个骰子之和小于10，则手气不怎么样
        if(count<10){
            System.out.println("今天手气不佳");
        }
        System.out.println("得了"+count+"分");
    }
}

    运行结果：

    	今天手气不佳
	得了6分

    新手雷区

    1.如果if语句不写{}，则只能作用于后面的第一条语句。

    2.强烈建议，任何时候都写上{}，即使是里面只有一句话!

if-else双选择结构

语法结构:

	if(布尔表达式){
    	语句块1
	}else{
   		语句块2
	}

当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图：

在这里插入图片描述

【示例】if-else结构

public class TestIfElse {
    public static void main(String[] args) {
        int h = (int)(6*Math.random()+1);
        System.out.println(h);
        if(h<=3){
            System.out.println("小");
        }else{
            System.out.println("大");
        }
        System.out.println("##################");
        //随机产生一个【0.0,4.0】区间的半径，并根据半径求圆的面积和周长
        double r = 4 * Math.random();
        //Math.pow(r,2)求半径r的平方
        double area = Math.PI*Math.pow(r,2);
        double circle = 2 * Math.PI*r;
        System.out.println("半径为："+r);
        System.out.println("面积为："+ area);
        System.out.println("周长为："+circle);
        //如果面积 >=周长，则输出"面积大于等于周长"，否则输出周长大于面积
        if(area>=circle){
            System.out.println("面积大于等于周长");
        }else{
            System.out.println("周长大于面积");
        }
    }
}

运行结果：

5
大
##################
半径为：3.5583835801143384
面积为：39.77914055712458
周长为：22.357983427883504
面积大于等于周长
if-else if-else多选择结构

语法结构

if(布尔表达式){
    语句块1;
}else if(布尔表达式2){
    语句块2;
}...
else if{
     语句块n 
    }else{
    语句块n+1;
}

当布尔表达式1为真时，执行语句块1；否则，判断布尔表达式2，当布尔表达式2为真时，执行语句

块2；否则，继续判断布尔表达式3…；如果1~n个布尔表达式均判断为假时，则执语句块n+1，也就

是else部分。流程图：

在这里插入图片描述

【示例】if-else if-else多选择结构

public class Test {
    public static void main(String[] args) {
        int age = (int)(100* Math.random());
        System.out.print("年龄是："+ age +",属于");
        if(age < 15){
            System.out.println("儿童，喜欢玩！");
        }else if(age<25){
            System.out.println("青年，要学习！");
        }else if(age<45){
            System.out.println("中年，要工作!");
        }else if(age<65){
            System.out.println("中老年，要补钙！");
        }else if(age<85){
            System.out.println("老年，多运动！");
        }else{
            System.out.println("老寿星，古来稀！");
        }
    }
}

运行结果：

年龄是：40,属于中年，要工作!
switch结构

语法结构

switch(表达式){
    case 值1:
    语句序列1;
    [break];
    case 值2:
    语句序列2;
    [break];
    	... ...	 ... ...
    [default:
    默认语句;]
}

switch语句会根据表达式的值从相匹配的case标签外开始执行，一直执行到break语句外或者

是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。

根据表达式值的不同可以执行许多不同的操作。switch语句中的case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。

当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。

switch多选择结构的流程图：

在这里插入图片描述

【示例】switch多选择结构

public class TestSwitch {
    public static void main(String[] args) {
        int month = (int)(1+12 * Math.random());
        System.out.println("月份："+month);
        switch (month){
            case 1:
                System.out.println("一月份！过新年了!");
                break;
            case 2:
                System.out.println("二月份！开春了!");
                break;
            default:
                System.out.println("我是其他月份!");
                break;
         }
        System.out.println("#################");
        char c = 'a';
        int rand = (int)(26 * Math.random());
        char c2 = (char)(c + rand);
        System.out.println(c2+":");
        switch (c2){
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                System.out.println("元音");
                break;
            case 'y':
            case 'w':
                System.out.println("半元音");
                break;
            default:
                System.out.println("辅音");
        }
    }
}

运行结果：

月份：11
我是其他月份!
#################
t:
辅音
循环结构
while循环结构

语法结构：

while(布尔表达式){
    循环体;
}

在循环刚开始时，会计算一个“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一个额外的循环，

都会在开始前重新计算一次。

语句中应有使循环趋于结束的语句，否则会出现无限循环——"死"循环。

while循环结构流程：

在这里插入图片描述

【示例】while循环结构：求100之间的累加和

public class TestWhile {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        //1 + 2 + 3 ...+ 100=?
        while (i<=100){
            sum += i; //相当于sum = sum+i;
            i++;
        }
        System.out.println("Sum=" + sum);
    }
}

运行结果：

Sum=5050

循环结构分两大类：一个是当型，一个是直到型。

当型：

当布尔表达式为true时，反复执行某语句，当布尔表达式为false时停止循环，比如：

while与for循环。

直到型

先执行某语句，在判断布尔表达式，如果为true，再执行某语句，如此反复，知道布尔表达式条

件为false时才停止循环，比如：do-while循环。

do-while循环

语法结构

do{
    循环体;
}while(布尔表达式);

do-while循环结构会执行循环体，然后在判断布尔表达式的值，如条件为真，执行循环体，当条件为假时结束循环体。do-while循环的循环体至少执行一次。do-while循环结构流程图：

在这里插入图片描述

public class TestDoWhile {
    public static void main(String[] args) {
        int i = 0; 
        int sum = 0;
        do{
            sum += i; //相当于sum = sum+i;
            i++;
        }while (i<=100);{//此处的，不能省略
        System.out.println("Sum=" + sum);
       }
   }
}

运行结果：

Sum=5050
for循环

语法结构

for(初始表达式;布尔表达式；迭代因子){
    循环体;
}

for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。for循环在第一次反复

之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，如判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的"步进"，即执行迭代因子。

  • 初始化部分设置循环变量的初值

  • 条件判断部分为任意布尔表达式

  • 迭代因子控制循环变量的增减

  • for循环在执行条件判定后，先执行循环体的部分，在执行步进。

    for循环结构的流程图：

在这里插入图片描述

【示例】for循环

public class TestFor {
    public static void main(String[] args) {
        int sum = 0;
        //1.求1-100之间的累加和
        for (int i = 0; i <= 100; i++){
            sum += i;
        }
        System.out.println("Sum=" + sum);
        //2.循环输出9-1之间的数
        for(int i = 9; i > 0; i--){
            System.out.print(i+"、");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for (int i = 90; i>0;i-=3){
            System.out.print(i+"、");
        }
        System.out.println();
    }
}

运行结果：

Sum=5050
9、8、7、6、5、4、3、2、1、
90、87、84、81、78、75、72、69、66、63、60、57、54、51、48、45、42、39、36、33、30、27、24、21、18、15、12、9、6、3、

Java能用逗号运算符的地方屈指可数，其中一处就是for循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列有逗号分隔的表达式，而且那些表达式均会独立执行。

【示例】逗号运算符

public class TestFor {
    public static void main(String[] args){
        for(int i = 1,j= i+10;i<5;i++,j=i*2){
            System.out.println("i=" + i + "j=" + j);
        }
    }
}

运行结果

i=1j=11
i=2j=4
i=3j=6
i=4j=8
  • 无论在初始化还是步进部分，语句都是顺序执行的。
  • 尽管初始化部分可以设置任意数量的定义，但都属于同一类型。
  • 约定：只在for语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。
  • 初始化部分、条件部分判断部分和迭代因子可以为空语句，但必须以 “；” 分开，如示例：

【示例】无限循环

public class TestFor {
	public static void main(String[] args){
    	for(;;){//无限循环：相当于while(true)
        	System.out.println("永远爱你！！！");
        }
    }
}

编译器将while(true)和for(；；)看做同一回事，都指的是无限循环。

在for语句的初始化部分声明的变量，其作用域为整个for循环体，不能在循环外部使用该变量。如示例

【示例】初始化变量的作用域

public class TestFor {

public static void main(String[] args){
    for(int i = 1; i<10; i++){
        //编译错误，无法访问在for循环中定义的变量i
        System.out.println(i);
        }
    }
}
嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层。

【示例】嵌套循环

public class TestWhileQian {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for (int j = 1; j<=5;j++){
                System.out.print(i+"\t");
            }
            System.out.println();
        }
    }
}


1	1	1	1	1	
2	2	2	2	2	
3	3	3	3	3	
4	4	4	4	4	
5	5	5	5	5

【示例】使用嵌套循环实现九九乘法表

public class TestWhileQian {
    public static void main(String[] args) {
 
        for(int n = 1;n<=9; n++){
            for (int m = 1; m <= n; m++) {
                System.out.print(m+"*"+n+"="+(m*n)+"\t");
            }
            System.out.println();
        }
    }
}

运行结果：

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

用while循环分别计算100以内的奇数及偶数的和，并输出。

 int sum01 = 0;
        int sum02 = 0;
        for(int i =1 ;i<=100;i++){
            if(i%2==0){
                sum01+=i;
            }else{
                sum02+=i;
            }
        }
        System.out.println("奇数和："+sum01);
        System.out.println("偶数和："+sum02);
    }
}

运行结果：

奇数和：2550
偶数和：2500

用while循环或其他循环输出1-1000之间能被5整除的数,且每行输出5个。

public class TestWhileQian {
    public static void main(String[] args) {
        int h = 0;
        for(int i =1; i<1000; i++){
            if(i%5==0){
                System.out.print(i+"\t");
                h++;
            }
            if(h==5){
                System.out.println();
                h=0;
            }
//            if(i%25==0){
//                System.out.println();
//            }
        }
    }
}

运行结果：

5	10	15	20	25	
30	35	40	45	50	
55	60	65	70	75	
80	85	90	95	100	
105	110	115	120	125	
130	135	140	145	150	
155	160	165	170	175	
180	185	190	195	200	
205	210	215	220	225	
230	235	240	245	250	
255	260	265	270	275	
280	285	290	295	300	
305	310	315	320	325	
330	335	340	345	350	
355	360	365	370	375	
380	385	390	395	400	
405	410	415	420	425	
430	435	440	445	450	
455	460	465	470	475	
480	485	490	495	500	
505	510	515	520	525	
530	535	540	545	550	
555	560	565	570	575	
580	585	590	595	600	
605	610	615	620	625	
630	635	640	645	650	
655	660	665	670	675	
680	685	690	695	700	
705	710	715	720	725	
730	735	740	745	750	
755	760	765	770	775	
780	785	790	795	800	
805	810	815	820	825	
830	835	840	845	850	
855	860	865	870	875	
880	885	890	895	900	
905	910	915	920	925	
930	935	940	945	950	
955	960	965	970	975	
980	985	990	995

break和continue语句

break用于强行跳出循环，不执行循环中剩余的语句。(终止整个循环)

【示例】break语句

public class TestBreak {
    public static void main(String[] args) {
        int total = 0;//定义定时器
        System.out.println("Begin");
        while (true){
            total++;//每循环一次计时器加1
            int i = (int) Math.round(100* Math.random());
            //当i等于88时，退出循环
            if(i == 88){
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over, used " +total+"times.");
    }
}

运行结果：

Begin
Game over, used 13times.

continue语句用在循环语句体中，用于终于某次循环过程，即跳过循环体中尚未执行的语句接

着进行下一次是否执行循环的判定。

注意事项

1.continue用在while，do-while中，continue语句立刻跳到循环首部，越过了当前循环的其余部分。

2.continue用在for循环中，跳到for循环的爹迭代因子部分。

【示例】continue语句：把100~150之间不能被3整除的数输出，并且每个输出5个

public class TestContinue {
    public static void main(String[] args) {
        int count = 0;//定义定时器
        System.out.println("Begin");
        while (true){
            total++;//每循环一次计时器加1
            int i = (int) Math.round(100* Math.random());
            //当i等于88时，退出循环
            if(i == 88){
                contniue;
            }
        }
        //输出循环的次数
        System.out.println("Game over, used " +total+"times.");
    }
}

运行结果：

100、101、103、104、106、
107、109、110、112、113、
115、116、118、119、121、
122、124、125、127、128、
130、131、133、134、136、
137、139、140、142、143、
145、146、148、149、

带标签的break和continue

goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的保留字，但并未在Java语言中得到正式使用；

Java没有共同语句。

【示例】带标签的break和continue：控制嵌套循环跳转(打印101-150之间所有的质数)

public class TestLabelContinue {
    public static void main(String[] args) {
        outer:for (int i =101;i<150;i++){
            for (int j  = 2;j<i/2;j++){
                if (i%j==0){
                    continue outer;
                }
            }
            System.out.print(i+"");
        }
    }
}

运行结果：

101103107109113127131137139149

语句块

语句块(有时叫做复合语句)，使用花括号扩起的任意数量的简单Java语句。块决定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部的变量不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

【示例】语句块

public class  Test{
    public static void main(String[] args){
        int n;
        int a;
        {
            int k;
            int n;//编译错误：不能重复定义变量n
        }//变量k的作用域到此为止
    }
}

方法

方法就是一段用来完成特定功能的代码片段，类似于其他语言的函数。

方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法

很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序有一个个函数调用组成。面向对象中整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

[修饰符1 修饰符2 ...]	返回值类型	方法名(形式参数列表){
    Java语句;	... ... ...	
}

方法的调用方式：

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

方法的详细说明

  1. 形式参数：在方法声明时用于接收外界传入的数据。
  2. 实参：调用方法时实际传给方法的数据。
  3. 返回值：方法在执行完毕后返回给调用它的环境的数据。
  4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为void。

【示例】方法的声明及调用

package com.company.pojo;

public class Test {
    /** main方法：程序的入口 */
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        //调用求和的方法：将num1与num2的值传给add方法中的n1和n2
        //求完和后将结果返回，用sum接收结果
        int sum = add(num1,num2);
        System.out.println("sum =" +sum);//输出：sum = 30
        //调用打印的方法：该方法没有返回值
        print();
    }
    /**求和的方法*/
    private static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;//使用return返回的计算结果
    }
    //打印的方法
    private static void print() {
        System.out.println("北京尚学堂...");
    }
}

运行结果：

sum =30
北京尚学堂...
  1. 实参的数目，数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
  2. return语句终止方法的运行并指定要返回的数据。
  3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是值的副本)：
  4. 基本类型传递的是该数据的copy值。
  5. 引用类型传递的是该对象音引用的copy值，但指向同一个对象。

方法的重载(overload)

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据

不同的参数自动匹配对应的方法。

雷区：

重载的方法，实际是完全不同的方法，只是名称相同而已。

构成方法重载的条件：

  1. 不同的定义：型参类型，形参个数，形参顺序不同。
  2. 只有返回值不同不构成方法的重载

如：

int a(String  str){}与void a(String str){}

不构成方法的重载

  1. 只有形参的名称不同，不构成方法的重载

如：

int a(String str){}与 int a(String s){}

不构成方法的重载

【示例】方法的重载

public class TestOverload {
    public static void main(String[] args) {
        System.out.println(add(3,5));//8
        System.out.println(add(3,5,10));//18
        System.out.println(add(3.0,5));//8.0
        System.out.println(add(3,5.0));//8.0
        System.out.println();
        //我们已经见过的方法的重载
        System.out.println();//0个参数
        System.out.println(1);//参数是1个int
        System.out.println(3.0);//参数是一个double
   }
        /*求和的方法*/
        public static int add(int n1, int n2){
            int sum = n1 + n2;
            return sum;
        }
        //方法名相同，参数个数不同，构成重载
        public static int add ( int n1, int n2, int n3){
            int sum = n1 + n2 + n3;
            return sum;
        }
        //方法名相同，参数类型不同，构成重载
        public static double add(double n1,int n2){
            double sum = n1 + n2;
            return sum;
        }
        //方法名相同，参数顺序不同，构成重载
        public static double add(int n1, double n2){
            double sum = n1 + n2;
            return sum;
        }
}

运行结果：

8
18
8.0
8.0

1
3.0

递归结构

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是"自己调用自己"，一个使用递归技术的方法将会直接或者间接的调用自己。

利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。

问题？

递归结构包括两个部分：

1.定义递归头：解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。

2.递归体。解答：什么时候需要调用自身方法。

【示例】递归计算n!

package com.company.pojo;

public class TestRecursion {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();
        System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n", d2-d1);//耗时：32ms

    }
    //求阶乘的方法
    static long factorial(int n) {
        if (n==1) {//递归头
            return 1;
        } else{//递归体
            return n*factorial(n-1);//n! = n*(n-1)!
        }
    }
}

运行结果：

10阶乘的结果:3628800
递归费时：16

递归的缺陷

简单的程序是递归的优点。但是递归的调用会占用大量的系统堆栈，内存消耗多，在递归调用层次多时速度要比循环慢得多，所以在使用递归时要慎重。

【示例】运行效果图
在这里插入图片描述

【示例】使用循环求n

public class TestRecursion2 {
    public static void main(String[] args) {
        long d3 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1){
            result *= a * (a - 1);
            a -=2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf("普通循环费时：%s%n", d4 - d3);
    }
}

运行结果：

3628800
普通循环费时：0

注意事项：

任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归；在要求高性能的情况下尽量避免使用递归，递归调用既费时又耗内存。

ID小白
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-03-28
weixin_45873466的博客
03-28 72
基于JS前端抽奖设计 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> <link rel="stylesheet" hre
键盘输入与控制语句
weixin_51994374的博客
12-01 197
##键盘输入 import java.util.Scanner; public class TestScanner{ public static void main(String[] args){ Scanner scanner = new Scanner(System.in); System.out.println("请输入名字 ："); String name = scanner.nextLine(); System.out.println("请输入爱好："); String f
Java学习第三章-控制语句（仅做个人学习笔记用）
Nlsrr的博客
04-04 215
3.1.1if单选择结构 语法结构： if(布尔表达式){ 语句块 } Math类的使用 1.java.lang包中的Math类提供了一些用于数学计算的方法。 2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。 int i = (int) (6 * Math.random());...
class-2021-03-25
04-01
【压缩包子文件的文件名称列表】"class-2021-03-25-main" 指示压缩包内可能有一个名为"class-2021-03-25"的主文件或目录，这可能包含了那天课程的所有相关资料。可能是PPT演示文稿、代码示例、阅读材料、练习题或者...
Pipeline-Trigger-2021-03-25T16-40-13.316Z:为工具链创建
03-26
标题中的“Pipeline-Trigger-2021-03-25T16-40-13.316Z:为工具链创建”暗示了这是一个关于持续集成（CI）或持续部署（CD）流程的项目，其中“Pipeline Trigger”可能指的是自动化构建或测试的触发器。日期和时间戳...
node-hello-worldWebIDE-UISimpleTC-2021-03-25T08-41-09.219Z-github:为工具链创建
03-25
日期戳“2021-03-25T08-41-09.219Z”表示这个项目是在2021年3月25日创建的，而“github”则意味着它托管在GitHub上。 描述中的“节点你好世界”进一步确认了这是一个初学者级别的Node.js项目，其主要目标是演示如何...
MFC 扩展库源代码合集 2021-03-25
03-25
CJ60Lib-V6.0.zip GuiLib-V1.5.zip GuiLib-V1.9.zip HuiDemo.zip MFCGridCtrl-V2.27.zip RingSDK.zip UltimateGrid-V7.3.zip UltimateTCP-IP-V4.2.zip UltimateToolbox-V9.3.zip 仿360sd杀毒.zip ...
node-hello-worldWebIDE-UISimpleTC-2021-03-25T18-39-49.882Z-github:为工具链创建
03-26
日期“2021-03-25”提示这是2021年3月创建的项目，而“github”则意味着该项目托管在GitHub上。 描述中的“节点你好世界”是中文的“Hello, World!”，通常用于初学者入门编程时展示的基础示例。在Node.js环境中，...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1248
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 793
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 264
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 312
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
springboot之自动装配
weixin_50153914的博客
07-23 469
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2388
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1371
Java实现拼图小游戏
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 348
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 277
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
.net判断"2021-03-07 21:25"是否是今天
05-25
DateTime dateTime = DateTime.ParseExact("2021-03-07 21:25", "yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture); // 获取今天的日期 DateTime today = DateTime.Today; // 判断日期时间是否是今天 bool is...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值