编程自学笔记

一、Java 1.安装 1.0 单词

单词	原意	计算机中的含义	备注
Windows	窗户的复数	指微软操作系统的名称	了解

1.1在Windows上安装Java

// 去【[官网下载]()】Windows 64位的软件包
// 配置 JAVA_HOME
 JAVA_HOME = "安装地址"
// 在path中配置JAVA_HOME
 %JAVA_HOME%\bin
//测试
java --version

1.2在Mac m1 上安装java

// 去【[官网下载]()】专属Mac m1的软件包
// 在多个版本间进行切换
// 1.创建.bash_profile文件
vim ~/.bash_profile
// 2.添加JDK的环境变量
export JAVA_8_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_281.jdk/Contents/Home
export JAVA_11_HOME=/Library/Java/JavaVirtualMachines/jdk-11.0.10.jdk/Contents/Home
export JAVA_15_HOME=/Library/Java/JavaVirtualMachines/jdk-15.0.2.jdk/Contents/Home
// 3.默认JDK1.8
export JAVA_HOME=$JAVA_8_HOME
// 4.alias命令动态切换JDK版本  
alias jdk8="export JAVA_HOME=$JAVA_8_HOME"  
alias jdk11="export JAVA_HOME=$JAVA_11_HOME"
alias jdk15="export JAVA_HOME=$JAVA_15_HOME"
PATH=$PATH:/usr/local/bin/
// 5.保存文件
:wq
// 6.立即生效
source ~/.bash_profile
// 7.测试可以先输入,查看当前版本
java --version
// 然后分别输入如下代码看是否切换成功
java15
java --version
java11
java --version
java8
java --version

1.3Java文件目录

目录名称	说明
bin	该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。
conf	该路径下存放了JDK的相关配置文件。
include	该路径下存放了一些平台特定的头文件。
jmods	该路径下存放了JDK的各种模块。
legal	该路径下存放了JDK各模块的授权文档。
lib	该路径下存放了JDK工具的一些补充JAR包。

1.4 Windows系统常识 常用命令

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd 目录	进入单级目录。cd itheima
cd …	回退到上一级目录。
cd 目录1目录2…	进入多级目录。cd itheimaJavaSE
cd	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

计算机基本内存换算

bit（位）是内存中最小的存储单位，byte(字节)是计算机最基本的存储单元。
可以这么理解，内存条中或者硬盘中都是以01存储的即按位存储；计算机中存储的数据以字节为单位存储。
一般而言：一个字母或一个数字都是1个字节，一个汉字为2个字节。
常见的字符集也有一个字母或一个数字都是2个字节，一个汉字为3个字节。
1B（字节） = 8bit —> B标识字节（byte） ，bit表示位
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

1.5 面试题

为什么配置环境变量？
开发Java程序，需要使用JDK提供的开发工具（比如javac.exe、java.exe等命令），而这些工具在JDK的安装目录的bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。我们不可能把所有的java文件都放到JDK的bin目录下，所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。

2.第一个Java程序

public 	class HelloWorld{
    public static void main(String[] args){
        System.out.println("hello world");
    }
}

###　2.0单词

单词	原意	计算机中的含义	备注

2.1Java软件开发程序

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。
cmd命令行执行顺序：

编译：javac 文件名.java
范例：javac HelloWorld.java
执行：java 类名
范例：java HelloWorld

对于一个程序或者程序开发、运行的过程中，bug无处不在。
**BUG：在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug（漏洞）。
BUG的解决
1、具备识别BUG的能力：多看
2、具备分析BUG的能力：多思考，多查资料
3、具备解决BUG的能力：多尝试，多总结
HelloWorld案例常见问题
1、非法字符问题。Java中的符号都是英文格式的。
2、大小写问题。Java语言对大小写敏感（区分大小写）。
3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。
4、编译命令后的java文件名需要带文件后缀.java
5、运行命令后的class文件名（类名）不带文件后缀.class

2.2初识类

类是Java中的最小的单位，Java中的一切都是类。一个Java文件中可以由无数个类，但是被public修饰的类只能由一个，且被public修饰的类的名称必须与Java文件的名称一致。

2.3注释

注释分为：
单行注释

//单行注释

多行注释

文档注释

//文档注释常用标记

3. 标识符&关键字&变量 3.1 标识符

Java是强类型语言，因此严格区分大小写。
Java命名方式采用驼峰式命名法，且要有意义的名词。
类名：首字母大写，后续每个名词首字母大写
方法和变量：首字母小写，后面每个单词大写。方法多采用动词，变量多采用名词。
标识符必须以字母、下划线、$开头，后面可以跟任意字母、数字、下划线、$。

3.2 关键字

关键字是指被java语言赋予了特殊含义的单词。
关键字的特点：关键字字母全部小写，且IDE工具中高亮显示。
(1)用于数据类型。
用于数据类型的关键字有 boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof。
(2)用于语句。
用于语句的关键字有break、case、 catch、 continue、 default 、do、 else、 for、 if、return、switch、try、 while、 finally、 throw、this、 super。
(3)用于修饰
用于修饰的关键字有 abstract、final、native、private、 protected、public、static、synchronized、
transient、 volatile。
(4)用于方法、类、接口、包和异常。
用于方法、类、接口、包和异常的关键字有 class、 extends、 implements、interface、 package、import、throws。
还有些关键字,如cat、 future、 generic、innerr、 operator、 outer、rest、var等都是Java保留的没有意义的关键字。
另外，Java还有3个保留字:true、false、null。它们不是关键字，而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。

3.3 变量

Java是强类型语言，所有变量必须先声明，在使用，指定类型的变量只能接受类型与之匹配的值。
在程序运行过程中，其值可以发生改变的量。

//第一种赋值声明
数据类型 变量名 = 变量值;
//第二种单个/多个声明，不赋值 
数据类型 变量名;
数据类型 变量名1，变量名2;
//第二种声明了不能直接使用，需要赋值
变量名 = 变量值;

变量注意事项：

1. 在同一对花括号中，变量不能重复声明。
2. 变量在使用之前，必须初始化（赋值）。
   ####　３.３.１变量在内存中的存储机制(特别重要)

Java程序运行内存可分为2种：
	- 堆内存。整个Java虚拟机运行时所持有的静态内存区。
		   JVM启动时，就有持有堆内存，堆内存会一直伴随JVM的运行。
	- 方法运行时，有一个临时的、动态的栈内存。简称方法的栈区。
	            方法执行时，系统为该方法分配栈区；
	  方法执行结束时，该方法的栈区会被自动销毁。
	堆：用于放置对象的 ,堆的容量是很大的
	栈: 放置变量,栈的区间是有限的。
	注意: 
	       变量赋值的解释：
	      - 对于基本类型的变量的赋值，程序就是把该值“装入”变量中。
	      - 对于引用类型的变量的赋值，程序不会把该对象“装入”变量中。
		    程序只是把对象所在内存的第一个Byte的编号（首地址）“装入”变量中。
		    相当于让引用变量指向“堆内存”中的对象。
		    所以引用变量实际上存放都可以认为是对象的地址。
	      所有new出来的对象全部是放到堆中
	    Java是一个静态语言，数组一旦被创建出来之后，该数组所在内存大小、内存位置都不能发生变化。
	    如果程序中某个对象不再有任何引用变量引用它，该对象就变成了“垃圾”，等待系统GC来回收它。
	GC:java的垃圾回收机制,没事就去看看堆中哪些对象没有变量引用,没有就把该对象清理掉。
	引用类型变量：本质是一个指针，保存的内存单元的编号（内存地址）。

4.基本数据类型 & 二进制

数据类型	类型名称	所占内存	取值范围
整型	byte	一个字节	-2^7 ~ 2^7-1
整型	short	两个字节	-2^15 ~ 2^15-1
整型	int(默认)	四个字节	-2^31 ~ 2^31-1
整型	long	八个字节	-2^63 ~ 2^63-1
字符型	char	两个字节	0 ~ 65535
浮点型	float	四个字节	很大
浮点型	double（默认）	八个字节	超级大
布尔类型	boolean	一个字节	值只有true和false，用于判断。

4.1整型 4.2浮点数：

浮点数有两种表示方式：
普通小数方式。
科学计数法:只要你用科学计数法表示数据,这个数据一定被当成小数。
浮点数有3个特殊值：
正无穷大（Infinity）
负无穷大(-Infinity)
非数(NaN)
所有正无穷大都相等，所有负无穷大都相等。
非数与任何数都不相等，与自身都不相等。
浮点数除以0，就会得到无穷大。
【整数不能处以0:执行会出现异常】
0.0除以0.0、对负数开平方，都会得到非数。

4.3 字符类型 4.基本数据类型的自动转换

自动类型转换：
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。

4. 基本数据类型的强制转换 4.基本数据类型的表达式自动提升 4. 常量、直接量

常量是作为变量的对立存在的，不同于变量，在程序运行过程中，其值不可以发生改变的量。
常量通常只有三种类似，基本数据类型、字符串类型、null类型
除空常量外，其他常量均可使用输出语句直接输出。

 		System.out.println(10); // 输出一个整数
        System.out.println(5.5); // 输出一个小数
        System.out.println('a'); // 输出一个字符
        System.out.println(true); // 输出boolean值true
        System.out.println("欢迎来到黑马程序员"); // 输出字符串

4.整型的注意事项

1. 对于任意的整数，在没有声明时，默认为int类型，无论是否在int范围中。
2. 对于任意的小数，在没有声明时，默认为double类型。
3. 当使用超出int范围的整数时需要在后面增加L用于标识，当想使用float类型的小数时，需要在小数后面增加F作为标识。LF建议使用大写，尤其L的小写在某些编辑器中和数字1类似。
4. 基本数据类型由小范围到大范围的转换，是自动升级。若大范围类型转换到小范围类型，需要强制类型转换。
5. 当进行强制类型转换时，很可能发生精度缺失。

4.二进制 5.初识String 6.运算符 6.3位运算符 位运算符

& ：按位与
| ：按位或
~ ：按位非
^ ：按位异或

第一个操作数	第二个操作数	按位与	按位或	按位异或
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

<<：左移运算符
>>：右移运算符
>>>：无符号右移运算符
进行移位运算时要遵循如下规则：

1. 对于取值范围低于int类型的操作数总是先自动类型转换为int类型后再移位。
2. 对于int类型的整数移位a>>b，当b>32时，系统先用b对32求余（因为int类型只有32位），得到的结果才是真正移位的位数。例如a>>33和a>>1的结果完全相同，而a>>32的结果和a相同。
3. 对于long类型的整数移位a>>b,当b>64时，总是先用b对64求余，得到的结果才是真正移位的位数。

7.流程控制 7.1 输入：Scanner 7.2 判断控制 7.3循环控制 8.数组 9.面向对象 9.0堆与栈 9.0.1堆（heap）：

​ 唯一目的：存放实例对象，Java虚拟机规范中描述是：所有的对象实例以及数组都要在堆上分配。

9.0.2栈（stack）：

虚拟机栈即常说的栈，用于存储局部变量，方法执行完自动释放。

9.0.3方法区（Method Area）：

用于存储已被虚拟机加载的类信息、常量、类变量（静态变量）。即时编译器编译后的代码等数据。

9.0.4内存区域：

内存区域包含：方法区、虚拟机栈、本地方法栈、堆、程序计数器。（运行时数据）
当一个对象被创建成功后，这个对象将保存在堆（heap）内存中，Java程序不允许直接访问堆内存中的对象，只能通过该对象的引用操作该对象。堆内存中的对象可以存在多个引用变量，即一个地址值赋值给多个引用变量。

9.1 类

类是Java中最小的可运行的单位。
类和对象是面向对象的核心，面向对象的三大特征是封装、继承、多态。

9.1.1类的定义：

[修饰符] class 类名{
  //构造器
  //成员变量
  //方法
}

9.1.2修饰符：

类的修饰符可以是：public、final、abstract、缺省。

9.1.3类的组成

类的成员一般是由 构造器（构造方法、构造函数）、成员变量、方法、代码块、内部类组成，但是对于一般类而言主要是由构造器、成员变量、方法组成。
类成员的定义顺序和编写顺序不影响运行顺序。但是被static修饰的成员不能访问无static修饰的成员。

public class Hello {
    static  int a ;
    public void ab(int a){
        System.out.println("我是一个没有被static修饰的方法");
    }
    public static void main(String[] args) {
        Hello.ab(a);
    }
}

编译上述代码时，IDE工具会提示，方法ab()需要被static修饰才能使用。
从广义上讲，类是一类事物的统称，例如人类、水果、水产、海鲜、汽车、国家等。
​ 成员变量是类的属性：例如人类都有名字、性别、职业等属性
​ 方法是类的行为：例如人类会走、运动、玩游戏、跳等行为。
​ 构造器是用于构造类的实例。

public class Person {
    public void Person(){
        System.out.println("我是构造器");
    }
    static String name;
    public static void sing(String name){
        System.out.println(name+"在唱歌");
    }
    public static void main(String[] args) {
        Person.name = "Bob";
        Person.sing(Person.name);
        Person hello = new Person();
        Person.name = "Jim";
        Person.sing(Person.name);
    }
}

9.2 成员变量 9.2.1成员变量的定义

【修饰符】类型 成员变量名[=默认值];

9.2.2修饰符：

权限修饰符：public、protected、缺省、private（任选其一）
关键字static&关键字final：这两个可以单独使用，也可以联合使用。
类型：可以是基本数据类型和Java已定义的引用类型，以及自己定义的类型。

9.2.3默认值：

数据类型	默认初始值
整型|浮点类型	0（L）|0.0（F）
boolean	false
引用类型	null
char	0（u0000）

9.2.4成员变量和局部变量

成员变量通常在类中，不在方法内声明，且成员变量不用static修饰的是实例变量和用static修饰的是类变量。
局部变量通常分为形参(在方法、构造器中定义变量)、方法局部变量（在方法内定义）、代码块局部变量（在代码块内定义的）
通常来讲任何变量的生命周期都是和其最近的代码块息息相关。即一个变量的最大作用范围一般不会超过最近代码块的范围。
成员变量和局部变量都有生命周期，局部变量除形参外，均需要显式初始化。

类目	成员变量	局部变量
声明位置	直接在被public修饰的类代码块中，不在其他代码块内	方法形参、代码块内、构造器内
修饰符	权限修饰符、static、final	只能使用final修饰符
初始化值	有默认初始化值	没有默认初始化值，必须显式赋值
内存加载位置	堆（heap）或静态代码块中	栈空间

9.3方法&方法的重载

方法是类或对象的行为特征的抽象，方法是类或对象最重要的组成部分。方法不能单独存在，必须定义在类中。方法在逻辑上要么属于类，要么属于对象。

9.3.1方法的定义

【修饰符】方法返回值类型 方法名(形参列表){
  //可执行语句
  //有返回值时
  return 返回值类型数据;
}

9.3.2方法的修饰符：

权限修饰符：public、protected、缺省、private，四选一
抽象修饰符：abstract 与 关键字final 互斥，二选一
上述修饰符都可以和关键字static相互使用。

9.3.3方法返回值类型：

方法分有返回值类型和无返回值类型
有返回值类型的方法在方法声明时指定返回值类型且方法中return对应的数据类型。
无返回值类型，用void声明，且方法中无return。

9.3.4形参列表

形参列表是零到多个，多个参数中间以英文逗号间隔，一旦存在形参则在使用方法时必须使用形参。可变参数必须是参数中最后一个参数，可变参数后面不允许有其他参数。
在方法体中，执行顺序是自上而下进行。

属性 参数传递机制 可变参数 方法的递归 方法的重载 9.4构造器

构造器是一个类创建对象的根本途径，一个类没有构造器则无法创建实例。
Java提供了一个功能，如果没有单独创建构造器，则默认提供一个无参构造器。但是，一旦程序员自己创建了一个构造器，Java程序则不在给与默认的无参构造器。

定义

【修饰符】 构造器名(形参列表){
  //可执行语句
}

修饰符：

权限修饰符：public、protected、缺省、private

构造器名

构造器名必须与类名一致。
构造器既不能定义返回值类型，也不可以使用void修饰。如果增加了返回值类型则Java就会将此构造器定义为方法执行。
构造器其实是有返回值的，即当类在实例化时，Java会调用构造器生成对象并返回该对象的地址值，即实例。构造器的返回形式是隐式的无需使用return。

9.5 关键字 static 作用：

用于区别成员变量、方法、代码块、内部类是属于类本身还是属于对象。

主要区别：

被static修饰的成员变量称为类变量，应当用类调用。未被static修饰的成员变量称为实例变量，应当被对象调用。
被static修饰的方法称为类方法，应当用类调用。未被static修饰的方法称为实例方法，应用被对象调用。

注意事项：

被static修饰的成员不能访问无static修饰的成员
实际操作中会发现被static修饰的成员变量和方法可以被对象调用，但是未被static修饰的成员变量和方法无法被类调用。

public class Demo001 {
    static String name;
    int age;
}
class Demo001Test{
    public static void main(String[] args) {
        Demo001.age = 12;//报错，编译不通过
        Demo001.name = "Bob";
        Demo001 d1 = new Demo001();
        d1.age = 12;
        d1.name = "Bobb";
    }
}

编译时上述代码中，Demo001.age = 12;此行会标红报错。
但是在从代码规范上来看，不推荐使用对象调用静态变量和静态方法。

9.6创建对象&&关键字 this 创建对象

类型 类变量名 = new 类型();

如果在定义引用类型的局部变量时为其制定了初始值可以使用var定义该变量。

var 变量名 = new 类型();

作用

访问实例变量，调用对象的方法。

对象的回收

如果希望通知垃圾回收器回收某个对象，只需切断该对象的所有引用变量和它之间的关可，即将引用变量赋值为null。

this关键字

关键字this总是指向调用该方法的对象，即谁在调用this指向的方法，this就代表谁。
常见的用法
1. 在构造器中使用是代表正在初始化的对象
2. 在方法中引用调用该方法的对象

	public class Dog {
    public void jump(){
        System.out.println("正在执行jump方法");
    }
    public void run(){
        //在此类中以下三种都是可以直接使用本类中的jump方法的
        Dog dog = new Dog();
        dog.jump();
        jump();
        this.jump();
        System.out.println("正在执行run方法");
    }
}

上述代码中的

        Dog dog = new Dog();
        dog.jump();

代表着只要Dog类实例化，并且调用run方法的话，此时程序中必然会有两个Dog类的实例。即你所想实现的效果被run方法内部的对象替代了，程序虽然正常运行，但是调用jump方法的对象却是run方法内部的对象了。
上述代码的

jump();

直接使用jump方法没有报错的原因是在一个类中非static修饰的方法之间是可以相互调用的，加不加this前缀的效果是一样的。此时的this并非不存在，而是隐性的存在。
可以测试将两个方法都加上static修饰时，三种方法均报错。

注意事项：

1. 关键字this指代的是对象本身，不能直接指代类本身。
2. 关键字this与static互斥，被static修饰的方法中不得使用关键字this。
3. 静态成员不能直接访问非静态成员。
4. 当确实需要在静态方法中调用普通方法，需要使用匿名对象调用。
5. 如果当在方法或构造器中，成员变量和局部变量同名，则需要在成员变量前面加上this前缀。
6. 关键字this的使用虽然可以让代码更加简洁，但是可能造成实际意义的模糊。

public class Demo01 {
    int testA;
    public Demo01 testF(){
        testA++;
        return this;
    }
    public static void main(String[] args) {
        Demo01 d = new Demo01();
        d.testF().testF().testF();
        System.out.println(d.testA);
    }
}

上述代码中方法testF中实例变量testA前省略了this，致使可能存在程序员阅读代码时误判。

9.7 封装 & 权限控制符 9.8 继承 && 关键字extends 9.9 关键字super 9.10 组合与继承 9.11 方法的重写 9.12代码块 & 类初始化 9.13包装类&处理对象 9.14 关键字final & 单例模式 9.15关键字abstract 9.16 关键字interface 9.17 内部类 &变量的作用范围 9.18 lambda表达式 9.19 枚举类 9.20 控制垃圾回收 9.21 修饰符作用范围 常用api 异常 泛型 集合 注解 JDBC IO流 多线程 网络编程 反射机制 JavaSE阶段项目 1.问答机器人 —>小滴课堂 2. 五子棋 —>《疯狂Java讲义》 3.人名币转换大小 ４.双色球 5.发扑克 MySQL HTML + CSS JavaScript & JQ&Ajax JavaWeb jsp servlet Tomcat HTTP XML UML Spring全家桶 Spring5 spring mvc spring Boot SpringCloud MyBatis Redis 整合框架SSM JVM&《深入了解虚拟机》 中间件 工作流 软件测试 LINUX 基础入门 系统管理 企业常用服务 Python Shell编程 pandas Numpy docker & K8S Vue Uni-app maven NoSql MongoDB node.js 基于python的数据结构–> 拓展Java的数据结构 算法 --> 一个题目两种解法：Java&Python TCP/IP协议 设计模式 计算机网络 负载均衡＆高可用集群 运维监控 自动化办公＆自动化运维 区块链 项目&案例&题目 国家职业技能证书 计算机操作员 计算机维修工 计算机网络管理员 计算机程序设计员 大数据工程技术人员 云计算工程技术人员 练习题 题目一：月份天数

给定月份和年份 输出当月的天数—>if&switch

题目二： 月份天数加强

给定年份和月份

春夏秋冬

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

【Java】

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入月份");
        int month = scanner.nextInt();
        switch (month){
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("输入的月份有误");
        }
    }

【Python】 计算0到100之间的奇数和偶数的和 【Java】

 public static void main(String[] args) {
        //计算0到100之间的奇数和偶数的和
        //定义偶数的和的变量
        int ouNumSum = 0;
        //定义奇数的和的变量
        int jiNumSum = 0;
        for (int i = 0; i <=100 ; i++) {
            if (i%2==0){
                ouNumSum += i;
            }
            if (i%2 != 0){
                jiNumSum +=i;
            }
        }
        System.out.println("偶数和为"+ouNumSum);
        System.out.println("奇数和为"+jiNumSum);
    }

【python】 求和

需求：求1-5之间的数据和，并把求和结果在控制台输出

【Java】 输出0-100的数，不包含3、5、7的倍数 【java】

//方法一：   
public static void main(String[] args) {
        for (int i = 0; i <100 ; i++) {
            if (i % 3 != 0){
               if (i%5!=0){
                   if (i%7!=0) {
                       System.out.println(i);
                   }
               }
            }
        }
    }
//方法二：
    public static void main(String[] args) {
        for (int i = 0; i <100 ; i++) {
            if (i%3!=0&&i%5!=0&&i%7!=0){
                System.out.println(i);
            }
        }
    }

关键点在于判断

排序一：输入三个整数，按照从大到小的顺序输出他们的值 【java】

  public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        int num1,num2,num3;
        System.out.println("输入第一个数字");
        num1 = scanner.nextInt();
        System.out.println("输入第二个数字");
        num2 = scanner.nextInt();
        System.out.println("输入第三个数字");
        num3 = scanner.nextInt();
        if (num1 >= num2){
            if (num3>=num1){
                System.out.println(""+num3+","+num1+","+num2);
            }
            if (num3 <= num2){
                System.out.println(""+num1+","+num2+","+num3);
            }
            if (num3<=num1&&num3>=num2){
                System.out.println(""+num1+","+num3+","+num2);
            }
        }else if (num1 <= num2){
            if (num3 >= num2){
                System.out.println(""+num3+","+num2+","+num1);
            }
            if (num3 <= num1){
                System.out.println(""+num2+","+num1+","+num3);
            }
            if (num3<=num1&&num3>=num2){
                System.out.println(""+num2+","+num3+","+num1);
            }
        }
    }

【python】

九九乘法表 【Java】 模拟登录

如果账号的密码错误3次，提示锁定账户，效果如下：
请输入账号：qtx
请输入密码：1234
登录失败
你还剩余 2 次机会
请输入账号：Qtx
请输入密码：1234
登录失败
你还剩余 1 次机会
请输入账号：Qtx
请输入密码：123456
登录成功

赌大小游戏

玩家的身家初始10000，实现下列效果：
少侠请下注: 30000
超出了你的身家，请重新投注。
少侠请下注: 8000
你摇出了5点,庄家摇出了3点
恭喜啦，你赢了，继续赌下去早晚会输光的，身家还剩18000
少侠请下注: 18000
你摇出了6点,庄家摇出了6点
打平了，少侠，在来一局？
少侠请下注: 18000
你摇出了4点,庄家摇出了6点
少侠,你输了，身家还剩 0
哈哈哈，少侠你已经破产，无资格进行游戏

循环小球

一个小球从100m高度落下,每次弹回原高度一半.
计算:
– 总共弹起多少次?(最小弹起高度0.01m)
– 全过程总共移动多少米?

双色球

36+1

绕圈圈

当输入4时：
01 12 11 10
02 13 16 09
03 14 15 08
04 05 06 07
当输入5时：
01 16 15 14 13
02 17 24 23 12
03 18 25 22 11
04 19 20 21 10
05 06 07 08 09

面向对象练习一

要求：创建Person类的对象，设置该对象的name、 age和sex属性，调用study方法，输出字符串
“studying”，调用showAge()方法显示age值，调用 addAge()方法给对象的age属性值增加2岁。

Java Person类

public class Person {
    String name;
    int age;
    String sex;
    public void study(){
        System.out.println("Studying");
    }
    public void showAge(){
        System.out.println(addAge(age));
    }
    public int addAge(int age){
        return age+=2;
    }
}

PersonTest类

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "Bob";
        p1.age = 12;
        p1.sex = "man";
        p1.study();
        p1.showAge();
    }
}

面向对象练习二 常见问题集合 问题一 问题场景 问题描述 原因分析 解决方案

参考资料：
书籍《疯狂Java讲义第五版》、《Java核心技术》、《Java编程思想》等