自习java的初火

---

1、初识java

java用于后台服务器，数据库处理

开发步骤

1 将编码写入Hello.java的文件中
2 通过javac对文件编译生成Hello.class文件
3 通过java命令对生成的Hello.class文件运行

什么是 JDK，JRE

JDK 基本介绍

1. JDK 的全称(Java Development Kit Java 开发工具包)
   JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]
2. JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。

JRE 基本介绍

1. JRE(Java Runtime Environment Java 运行环境)JRE = JVM + Java 的核心类库[类]
2. 包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

JDK、JRE 和 JVM 的包含关系

1. JDK = JRE + 开发工具集（例如 Javac,java 编译工具等)
2. JRE = JVM + Java SE 标准类库（java 核心类库）
3. 如果只想运行开发好的 .c

---

2、基本使用

基本代码：

public	公共的，意味着从程序任何地方都可以访问它。
static	静态方法，意味可以在不创建类的情况下调用，这是因为main方法需要作为程序的入口点，而程序在执行前还没有创建类的实例。
void: 这是方法的返回类型。main方法在执行完毕后不返回任何值。
main	【是方法的名称】
(String[] args): 这是方法的参数列表。main方法接受一个参数，这个参数是一个字符串数组（String[]），通常命名为"args"，它用来接收命令行参数。
命令行参数是在运行Java程序时传递给程序的信息，例如从命令行传递的文件名、选项等。

2.1.0 Scanner 键盘输入`

一、用法

import java.util.Scanner//首先导入java.util.Scanner包
public class main{
	pubilc static void mian(String[] args){
	Scanner sc = new Scanner(System.in);//从键盘接受数据
	String s = sc
	}
}

二、在“空格”前的词都会被删掉，只输出空格后的

//导入包//
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {  
		
    Scanner  sc=new Scanner(System.in);//从键盘接收数据//
 
    sc.useDelimiter("\n"); //修改输入数据的分隔符//
    String s=sc.next();
    System.out.println(s);
System.out.println（s）;
    
	}
 
}

2.1.1 DOS命令提示符

操作	说明
盘符名称	盘符切换
dir	查看当前路径下的内容
cd	进入单级目录
cls	清屏
exit	退出命令提示符窗口

2.1 转义字符

1) 在控制台，输入 tab 键，可以实现命令补全
2) \t ：  制表位，实现对齐的功能
3) \n ：  换行符
4) \\ ：    \
5) \" :     "
6)	\r\n: 回车

2.2 Java程序的基本格式

//class用于创建.class
修饰符 class 类名 {
	程序代码;
	}

3 变量

a.整型 (byte short int long)

byte		32byte
short		16byte
int			32byte
long		64byte

b. 浮点数

float		4 byte		特殊输出	float f=4.5f;	
double		8 byte		更加精确

c. 字符类型

char		变量需要单引号

d.布尔类型

boolean isPass = true;		只有ture和false

e.数据转换

精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换

多种类型的数据混合运算时，系统先自动将数据转换为容量最大的数据类型，然后进行计算

1、隐式转换
将数据类型中，取值范围小的数据，给取值范围大的类型赋值，直接赋值
简单记小转大，直接转

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型

2、强制转换
把一个表示数据范围大的数值或变量赋值给另一个数值范围小的变量

4.运算符

1、基本运算符
1、a++的结果跟程序执行过程有关,有可能是加上1,有可能不加1.

2、++ 和 --可以放在变量的后边，也可以放在变量的前面

2、关系运算符

符号	说明
= =	a= =b,判断a和b的值是否相等
！=	不相等
>
>=
<
<=

3、逻辑运算符

符号	读作	说明
&	与	一错则错
|	或	一对则对
！	非	相同则对
^	异或（相同为false，相反为true）	相反则对
&&	短路与	作用与&相同，但有短路效果
||	短路或	作用与&相同，但有短路效果

package project2;           

public class logic {
	public static void main(String[] args) {
		int x = 3;
		int y = 4;
		System.out.println(x++ <= 1 & --y <55);
		System.out.println("x="+x);
		System.out.println("y="+y);
		System.out.println(x > 1 | y >2	);
	//三元运算符
		int a=32;
		int b=1231;
		int z = 2;
		int aa=a>b?a:b;
		int aaa=a<b?a:b;
		System.out.println(aa);//错误，输出b
		System.out.println(aaa);//正确，输出a	
	}	
}

5、流程控制语句

1、if

eg：考试成绩

package project2;        

import java.util.Scanner;

//题目：输入考试成绩，合格输出，不合格输出
public class ProcessControl {
	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in);
		System.out.println("Enter test scores:");
		int score = sc.nextInt();
		//The foundation is complete, and the next step is the if statement
		if(score >= 95 && score <=100) {
			System.out.println("Mom's gonna buy you a four-wheel drive");}
		else if(score >= 60 && score<95) {
			System.out.println("I was praised by the teacher, confidence boost");
		}
		else if(score<60) {
			System.out.println("I'm used to telling myself that grades don't matter");
			}
		else {
			System.out.println("Steady grades. You can push it\r\n");		
			}
		}
	}

2.switch

    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    default:
        语句体3;
        break;
}

3.case穿透

	如果switch语句中，case省略了break语句，就会开始case穿透
	现象:当开始case穿透，后序的case就不会具有匹配效果，内部的语句都会执行
	直到看到break,或者将整体switch语句执行完毕，才会结束

4.for

for(初始化语句;条件判断语句;条件控制语句){
    循环体语句;
}

eg

//求1-5数据和
int a = 4;
for(i=0;i<=a;i++){
	b+=i
} 
System.out.println(b);   

5、while

初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

1.案例:珠穆朗玛峰

public class Demo{
    /*
    需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
	请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
    */
    public static void main(String[] args){      
        // 1.定义计数器变量，准备用于统计折叠的次数
        int count = 0;
        // 2.准备纸张厚度变量,珠峰高度变量
        double paper = 0.1;
        int zf = 8844430;
        // 3.不确定循环次数，使用while循环
        while(paper <= zf){
            paper *= 2;
            System.out.println(paper);
            // 每折叠一次,计数器就要自增
            count++;
        }
        System.out.println(count);
        
    }
}

6.dowhile

初始化语句;
do{
    循环体语句;
    条件控制语句;
}while(条件判断语句);

8.死循环

1.for死循环

public class Demo{
    public static void main(String[] args){           
        // for死循环格式
        for(;;){
            System.out.println("我停不下来了");
        }
    }
}

2.while死循环

public class Demo{
    public static void main(String[] args){      
        while(true){
            System.out.println("我停不下来了");
        }
    }
}

3.dowhile死循环

public class Demo{
    public static void main(String[] args){       
       do{
           System.out.println("我停不下来了");
       }while(true);
    }
}
命令提示符窗口中 Ctrl+C 可以结束死循环

9.continue

作用: 跳过某次循环体内容的执行

public class Demo{
    public static void main(String[] args){       
        // 模拟电梯上升，1-24层，4层不停
        for(int i = 1;i <= 24 ;i++){
            if(i == 4){
                continue;
            }
            System.out.println(i + "层到了~");
        }
    }
}
.break
作用:终止循环体内容的执行

public class Demo {
    public static void main(S

10.break

作用:终止循环体内容的执行

public class Demo {
    public static void main(String[] args){     
        // 模拟20岁工作到80岁，60岁退休
        for(int i = 20; i <= 80; i++){
            if(i == 60){
                break;  //结束整个循环
            }
            System.out.println(i + "岁正在上班");
        }
    }
}

6、数组

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理

2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

3. 数组创建后，如果没有赋值，有默认值int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

4. 使用数组的步骤：a 声明数组并开辟空间 b 给数组各个元素赋值 c 使用数组

5. 数组的下标是从 0 开始的。

6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如

1.数组定义

int[] array;
//格式二：数据类型 变量名[]
int array[];
//定义了一个int类型的数组，arr
int[] arr;
System.out.println(arr[])             

2、数组动态初始化

格式：
	数据类型[]变量名 = new 数据类型[数组长度]
	int[] arr = new int[3];
	System.out.println(arr[0]);//0系统自动分配的默认初始值

3、数组静态初始化

格式一: 数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3,.....}
int[] arr = new  int[]{1,2,3};

简化格式: 数据类型[] 变量名 = {数据1，数据2，数据3，....}
int[] arr = {1,2,3};

动态初始化：手动指定数组长度，系统默认赋值0
静态初始化：手动指定数组长度，计算数组长度

4、数组遍历

//动态获取数组元素个数：数组名.length

int[]arr = {11,22,33,44,55};
for(int i =0 ;i<arr.length; i++){
	System.out.println(arr[i]);     

5、查找数组

package project2;                      
import java.util.Scanner;
	public class find {
	public static void main(String[] args){ 
	//加收用户输入，遍历数组，逐一比较，如果有则提示信息
	
	//定义一个字符串数组
	String[] names= {"白眉","bbbb","cccc","ddddd","cccc"};
	Scanner myScanner = new Scanner(System.in);
	
	System.out.println("输入名字"); 
	String findName = myScanner.next();
	
	//遍历数组，逐一比较
	for(int i = 0;i<names.length;i++) {
		//比较 字符串比较equals
		if(findName.equals(names[i])) {
			System.out.println("恭喜你找到"+findName); 
			System.out.println("下标为="+i); 
			break;
			}
		}
	}
}

7、二维数组

7、面向对象

1、类

封装（Encapsulation）：类允许将数据和方法封装在一个单一的单元中。这意味着类可以隐藏其内部实现细节，只暴露必要的接口给外部世界。这有助于维护数据的完整性和安全性。

继承（Inheritance）：继承是面向对象编程中的重要概念，它允许一个类继承另一个类的属性和方法。这促进了代码重用和层次结构的构建。子类可以继承父类的特征并添加自己的特征。

多态（Polymorphism）：多态性允许不同的类对象对同一消息作出响应，但可能有不同的实现方式。这提高了代码的灵活性和可扩展性。多态性可以通过继承和接口实现。

抽象性（Abstraction）：抽象类和接口允许定义没有具体实现的方法，这些方法在子类中进行实现。这有助于将问题分解为更小的、可管理的部分，以及提供了一种规范的方式来定义类的行为。

实例化（Instantiation）：类是对象的模板，而实例是基于类创建的具体对象。通过实例化，可以创建类的多个对象，每个对象都具有相同的结构和行为，但可能具有不同的状态。

属性和方法：类可以包含属性（也称为字段或成员变量），用于表示对象的状态，以及方法，用于定义对象的行为。属性和方法是类的成员。

可见性控制：类的成员可以使用访问修饰符（例如 public、private、protected、default 等）来控制其可见性和访问权限。这有助于控制成员的访问级别，以维护封装性。

构造函数：类可以包含构造函数，用于初始化类的对象。构造函数在对象创建时自动调用，通常用于设置对象的初始状态。

public static void main(String[] args){    
```java
//访问修饰符 返回数据类型 方法名 （形参列表..）
public static void 方法名字（）{
//
}

//example
public static void eat(){
    //方法体
}

1、方法调用

方法名();

//example
eat();

注意
1、方法必须先定义后调用
2、方法与方法之间是平级关系，不能嵌套定义
3、方法没有被调用是，需要假如栈内存中运行

奇偶数判断

public class Demo{
    public static void main(String[] args){                   
        // 3. main 方法中调用method
        method();
    }
    // 1.定义method方法
    public static void method(){
        // 2.方法中定义变量,使用if语句判断是奇数还是偶数
        int num = 10;
        if(num % 2 ==0){
            System.out.println("偶数"); 
        }else{
            System.out.println("奇数"); 
        }
    }
}

2，带参数的方法

public static void 方法名(数据类型变量名1,数据类型变量名2,....){.}

    
public static void getMax(int number1,int number2){....}