一、环境配置
1、安装JDK
2、①设置环境变量：我的电脑→属性→高级系统设置→高级环境变量→复制bin路径添加到Path
②新建系统变量 JAVA_HOME=到bin之前路径
③删除第一步中Path中的bin路径；Path中新增 %JAVA_HOME%bin
二、运算符和控制语句
运算符：在表达式中用来表示运算的符号
一、算术运算符：+、-、/（除法）、*（乘法）、%（取余）、–、++i、i++（后导自增，先使用后自增）
二、三目运算符/条件运算符
:条件表达式？结果表达式1：结果表达式2；
流程：如果条件表达式为true，则整个结果表达式为1，否则为结果表达式2
比较两个数是否相等
int d = 30;
int e = (a>b?a:b)>d?(a>b?a:b):d;
System.out.println(e);
int a = 10;
int b = 20;
boolean res = a==b?true:false;//先判断a是否等于b，如果成立输出true
四、扩展运算符
+=、 -=、*=、/=、 %=
含义：对变量进行操作后，值再次赋给变量
int a = 1;
a += 3 ;
结果：a=1+3=4
五、比较运算符
==、!=、>、<、>=、<= 比较两个值是否相等，不相等……
比较结果为boolean类型的值true或flase
六、逻辑运算符
与或且& 或 | 异或 ^ 非! 短路与 && 短路或||
含义：逻辑运算符用于连接boolean 类型的表达式，结果亦为boolean值
& 与|且：全真为真，否则为假
| 或 ：有真为真，否则为假
! 非 ：真为假，假为真
^ 异或：相同为假，相异为真
&& 短路与（全都要成立）：全真为真，遇假短路
|| 短路或（全都不能成立）：全假为假，遇真短路
public class test1{
public static void main(String[]args){
boolean b3 = (1>2)&&(3>2);//表达式1为假，整个表达式就是假。dead code（死的代码）
System.out.println(b3);
boolean b4 = (1>2)||(3>2);//表达式1结果可以确认整个结果
System.out.println(b4);
b3 false b4 ture
二、键盘录入
实际开发中，，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。
步骤：1:导包
import java.util.Scanner;
位置：在package下面，并且在class的上边
2:创建对象/工具
Scanner sc = new Scanner(http://System.in);
3:获取数据
int num = sc.nextInt();
package com.shsxt;
//引入scanner工具类
import java.util.Scanner;
public class Test06_scanner {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入你的年龄：");
int age=sc.nextInt();
System.out.println("请输入你的姓名：");
String name=sc.nextLine();
System.out.println("请输入你的爱好：");
String favor=sc.nextLine();
System.out.println("*****************");
System.out.println("姓名："+name);
System.out.println("年龄："+age);
System.out.println("爱好："+favor);
}
}
三、随机函数
随机生成函数：Math.random()
此函数的返回值为double类型，其取值范围[0.0,1.0)。
随机数公式：[min, max] == Math.random() * (max-min+1) + min Math当中的常用函数
绝对值函数 Math.abs(); 平方根函数 Math.sqrt();
package com.shsxt;
import java.util.Random;
public class Test07_random {
public static void main(String[] args) {
Random rand = new Random();
int num = rand.nextInt();
int num1 = rand.nextInt(100);
System.out.println(num);//随机的数，
System.out.println(num1);
}
}
四、流程控制语句
几乎在所有的语言理都存在大同小异的流程控制语句，一般分为三种
(1)顺序结构 从上往下，依次执行 (2)选择结构 按照不同的选择，执行不同的代码(3)循环结构 做一些重复的代码
一、顺序控制
JAVA 的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
二、选择控制
1、单分支
if(表达式){
语句
}
//注意：省略花括号，只会影响它下面的第一行语句
//表达式成立，则执行语句；如果不成立，不执行
public static void main(String[] args) {
int a = 10;
if(a<6){
int b = 1;
b++;
System.out.println("你好厉害呀");
}
if(a<8){
int c = 1;
c++;
System.out.println("到最后还是我厉害");
}
if(a>9){
System.out.println("到底谁厉害");
}
}
//输出结果为“到底谁厉害”
双分支
/*
* 双分支
*
* if(表达式){
*
* }else{
*
* }
*
*/
public static void main(String[] args) {
int score = 80;
if(score>=60){
System.out.println("万事大吉");
}else
System.out.println("不及格，你可要注意了");
System.out.println("你看着办");
}
}
//输出结果：万事大吉
// 你看着办
多分支
//评判学生的分数等级
public static void main(String[] args) {
int score = 80;
if(score>90){
System.out.println("优秀");
}else if(score>=80&&score<90){
System.out.println("中等");
}else if(score<80&&score>=70){
System.out.println("良");
}else if(score<70&&score>=60){
System.out.println("及格");
}else{
System.out.println("上点心了");
}
}
//输出结果：中等
2）switch选择
switch选择也称定值选择，做的是等值比较。 根据表达式值的不同执行许多不同的操作，
switch 语句：case 标签必须是整数(byte,short,int,char)或枚举或字符串
switch:也可以作为选择判断，但是是等值比较
break:用来终止swtich语句
switch和if的区别：switch的可以完全被if代替，但是if的不一定被switch替代。if可以进行范围判断
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份");
int month = sc.nextInt();
switch(month){
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;
case 12:
case 1:
case 2:
System.out.println("冬天");
break;
default:
System.out.println("没有这个月份");
}
}
3、循环结构
一、循环控制
循环即重复地执行一些相同或类似的操作
1、while循环
当条件满足时执行，也叫当到型结构
**while(条件){
循环体
迭代因子
}
**
public static void main(String[] args) {
int i = 1;//初始化数据
while (i >= 5) {//表达式 用来判断是否需要执行语句的
System.out.println("你好");
i = i + 2;//迭代因子
}
//以上输出无结果（while先判断，再执行，若是判断不成立直接退出循环）
System.out.println("**************");
int j = 5;
do {
System.out.println("你好啊");
j = j - 1;//迭代因子
}while(j>=1);
}
}
2、do…while
初始语句
do{
循环体
迭代因子
}while（布尔表达式）; //分号不能缺少
执行循环，直到条件不满足退出循环。先执行循环体，再判断
循环体至少执行一次
for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构 for 循环在执行条件测试后，
先执行程序部分，再执行迭代因子( ( 步进) ) 。
初始化部分、条件判断部分和迭代因子可以为空语句，但以“;”分开，下面的语句表示无限循环
for(初始化的表达式;条件判断语句;迭代因子){循环体}
/*
* for(初始化的表达式;条件判断语句;迭代因子){循环体}
* ""在java中用来表示String，也就是字符串
*/
public class Test13_for {
public static void main(String[] args) {
//int i = 1;
for(int i=1;i<=5;i++){
System.out.println("Hello World");
}
System.out.println("************");
for(int i=1;i<=10;i++){//这里的i是局部变量，只在当前的for循环语句中使用
System.out.println(i);
}
//System.out.println(i);//i是全局的，所以查找的就是全局的i。局部的i影响了全局的i
for(int i=10;i>=1;i--){
System.out.println(i);
}
}
}
循环嵌套
循环嵌套指的是在一个循环语句内部再嵌套一循环或者多个循环，类似if的嵌套
需求：请在控制台输出一个5行5列的矩形（用* 来表示）
1、i=1的时候，表达式成立，执行循环体，
1）此时j=1，符合条件，执行循环体
2）j=2，符合条件，执行
3）j=3，符合条件，执行
。。。
2、i=2的时候，表达式成立，执行循环体
1）此时j=1，符合条件，执行循环体
2）j=2，符合条件，执行
3）j=3，符合条件，执行
。。。
public class test_for_if {
public static void main(String[]args){
for(int i=1;i<=5;i++){
for(int j=1;j<=5;j++){
System.out.print("*");
}
System.out.println("");
}
}
}
break&continue
-
break:终断
A:用在循环和switch语句中，离开此应用场景无意义。
B:作用：跳出单层循环 -
continue:继续
A:用在循环中，离开此应用场景无意义。
B:作用：跳出单层循环的一次(本次)，继续下一次循环
在1–10之间，输出前7个数
public class test_break_continue {
public static void main(String[]args) {
for (int i = 1; i <= 10; i++) {
if (i == 7) {
continue;//当i==7的时候，不再执行循环体后面的内容，而是执行下一次循环
}
System.out.println(i);
}
//输出结果为12345689没有7，因为当i==7的时候跳过了本次循环，没有执行循环体后面的内容
System.out.println("**************");
for(int i =1;i<10;i++){ //在1--10之间，输出前7个数
if(i>7){
break;
}
System.out.println(i);
}
}
}
四、死循环
死循环是指条件永远为true,注意死循环不一定是错误的，如服务器就是一个大大的死循环，不间断服务着。
最简单的死循环格式
for(;;){}
public static void main(String[] args) {
//for(;;){} 最简单的死循环
int a = 1;
//死循环
while(true){
System.out.println("你真好看");
a++;
if(a>10){
break;
}
System.out.println(a);
}
}
//输出结果：你真好看2你真好看3你真好看……10你真好看
四、方法，void,return,递归
1、方法：就是 给能够解决问题的多行代码取了一个名字的功能块 ，方便我们多次使用。
形参列表:参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。
方法的分类：
返回值的类型：基本数据类型，引用数据类型
void :无返回值的时候使用
public class Method02 {
public static void main(String[] args) {
//main方法中的前半部分代码
print();
//main方法中的后半部分代码
if(isTrue()){
System.out.println("判断结果为真");
}
add(1);
System.out.println(cal(10,3));
}
//无参无返回值方法
public static void print(){
System.out.println("输出语句");
return;
}
//无参有返回值方法
public static boolean isTrue(){
//伪代码，用来判断数据，判断结果是否为真
return true;
}
//有参无返回值方法
public static void add(int a){
a++;
//什么都不操作
}
//有参有返回值方法
public static int cal(int a,int b){
return a-b;
}
//
public static void compare(int a,int b){
if(a>10){
System.out.println("a是大于10的数");
return;
}
if(b<9){
System.out.println("b是小于9 的数");
return;
}
}
}
2、return关键字
return 为 跳出方法 或 返回值。 注意：在一个作用域内 return 之后不能再存在代码 return语句:
①return语句可以出现在任何(有返回值和没有返回值)方法中
②return语句 在没有返回值的方法中，用来提前结束方法
③return语句 在有返回值的方法当中，有两个作用：提前结束方法，送出结果。
④一个方法只能执行一条return语句
⑤在一定会被执行的return语句后，写的语句为不可达语句，程序自动检测这种语句，永远不会被执行到，报错。
⑥在循环中无条件的break后写语句和在死循环(没有break来结束的死循环)后写语句，都会出现不可达语句
编写一个方法时，请思考这四个方面:
1)、确定方法的功能
2)、确定方法的名称
3)、此方法能否独立运行，不能独立，需要外界数据参与运算，确定形参。
4)、此方法完成后，其结果是否直接影响调用处的后续操作，如果影响，确定返回类型，不影响则为 void
3、签名(signature)
方法的签名，确保在一个类中的唯一性方法的签名只看方法名和形参( 类型个数和顺序) ，
与修饰符 返回类型和形参名无关。
重载（method invoke）
一般来说，功能点相同的方法才适合使用重载，重载必须满足如下要求：
①必须是同一个类
②方法名必须相同
③参数列表不同
注意：方法重载与返回值无关。
参数列表不同：
参数的个数不同。
参数的对应的数据类型不同。
参数的顺序不同(不同类型的可以交换位置)
方法重载：
出现的情况:同一个动作，但是形参的个数不一样，所以出现方法重载
两个相同三个不同：
同类（在同一个类中）同名（方法的名字相同）
形参的个数、类型以及顺序
跟返回值无关
-
面向对象（方法重写）
-
`public static void main(String[] args) {
//求2+3的和
int result = add(2,3);
System.out.println(result);
//求2+3+4的和
//result = add(2,3,4);
System.out.println(result);
//调用double的参数
System.out.println(add(1.0,2));
System.out.println(add(1,2.0));}
//加法的方法定义
public static int add(int a,int b){
return a+b;
}public static double add(double a,double b){
return a+b;
}
`
数组
数组是相同类型数据的有序集合。这些按序排列的同类数据元素的集合称为数组“[]”。数组长度确定之后不能改变。
数组声明格式：
数据类型[] 数组名称; --推荐使用
double [] arr; --推荐使用
数据类型 数组名称[];
char arr[];
动态初始化：
数据类型[] 数组名=new 数据类型[长度];
int[] data = new int[5];
静态初始化
数据类型[] 数组名=new 数据类型[]{值1,值2…}; //int[] date = new int[]{1,2}
数据类型[] 数组名={值1,值2…}; --当面的简写方式 //int2[] date = {1,2}
普通for循环
for(int 索引=0；索引<长度; 索引++){ for(int i=0;i<arr.length;i++){
数组名称[索引] = 值； System.out.println(arr[i]);
}
int[] arr={1,2,3,4};
//1.遍历数组---基本for循环
for(int i=0;i<arr.length;i++){
//变量i代表索引/元素的下标
System.out.println(arr[i]);
}
增强for循环
for(元素类型 局部变量 ： 数组){
局部变量–>为数组中的每一个元素值,从左向右以此获取 }
遍历数组—增强for循环 for(int i : arr){
System.out.println(i); //i中存储数组的元素值,非索引 }
动态初始化
int[] arr = new int[3];
Arrays中常用方法：
打印数组 ----toString方法（打印数组）
比较两个数组是否相同 ----equals方法（比较两个数组是否相同 ）
数组排序 ----sort方法 （数组排序 ）
数组查找 ----binarySearch 方法（数组查找）
数组拷贝 ----copyOf方法（数组拷贝）
数组拷贝 ----copyOfRange方法（数组拷贝）
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
