JAVA基础笔记

最新推荐文章于 2024-07-09 16:46:46 发布

Guangshan Hu

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量446

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/xhy1996/article/details/122079690

版权

5. 工具下载（JDK11 & Eclipse）Mac版

3. continue 和 break的用法及区别

第一节

1. JAVA起源及演变

1991 年，SUN公司的詹姆斯·高斯林(James Gosling)领导项目小组（名为“Green”）开发一种能够在各种消费性电子产品上运行的程序架构，在1992年创作了面向对象语言‘’OaK“，1994年用其研发了Applet（能将小程序嵌入到网页中执行的技术，还可随同网页在网络上进行传输），并将“OaK”更名为JAVA

1996 年 1 月	JDK 1.0	Java 虚拟机、Applet、AWT 等
1997 年 2 月	JDK 1.1	JDBC、JavaBeans、RMI、JAR 文件格式、Java 语法中的内部类和反射
1998 年 12 月	JDK 1.2	第二代 Java 平台的企业版 J2EE 发布
1999 年 4 月		名为“Longview Technologies”的小公司开发HotSpot 虚拟机，后来被 SUN 公司收购,作为 JDK 1.2 的附加程序提供
1999 年 6 月	JDK 1.2	发布多体系和API；Swing、Java IDL、EJB、Java Plug-in 等，在 API 文档中，添加了 strictfp 关键字和 Collections 集合类体系： J2ME(Java2 Micro Edition，Java2 平台的微型版)，应用于移动、无线及有限资源的环境; J2SE(Java 2 Standard Edition，Java 2 平台的标准版)，应用于桌面环境; J2EE(Java 2Enterprise Edition，Java 2 平台的企业版)，应用于基于 Java 的应用服务器 API： Java Core API:Java 核心类库; Java Optional API:对之前 API 的扩充; 特殊 API:由特殊厂商或组织提供的 API。
2000 年 5 月	JDK1.3、JDK1.4 和 J2SE1.3 相继发布	JavaSE1.3 已经涵盖了数据库、WEB、网络、图形、多媒体、电话、影像等大部分的信息技术领域
2002 年 2 月	J2SE1.4 发布	提供了广泛的 XML 支持、安全套接字(Socket)支持(通过 SSL 与 TLS 协议)、全新的 I/OAPI、正则表达式、日志与断言
2004 年 9 月	J2SE1.5 发布（Java SE 5.0）	里程碑式重要版本1，更名为5.0；其中包括泛型支持、基本类型的自动装箱、改进的循环、枚举类型、格式化 I/O 及可变参数
2005 年 6 月	Java SE 6	各版本改名，取消了名字中的2
2011 年 7 月	Java SE 7	引入了二进制整数、支持字符串的 switch 语句、棱形语法、多异常捕抓、自动关闭资源的 try 语言等新特性
2014 年 3 月	Java SE8	全新的 Lambda 表达式、流式编程等大量新特性
2017 年 9 月	Java SE 9	强化了 Java 的模块化系统，让 Java 语言更轻量化，且采用了更高效、更智能的 GI 垃圾回收器，并在核心类库上进行大量更新，可进一步简化编程
2018 年 3 月	Java SE 10	局部变量类型推断，垃圾收集器改善、GC 改进、性能提升、线程管控等新特性。
2018 年 9 月	Java SE 11	Java 大版本周期变化后的第一个长期支持版本(LTS 版本持续支持到 2026 年 9 月) 带来了 ZGC、Http Client 等重要特性，一共包含 17 个 JEP (JDK Enhancement Proposals，JDK 增强提案)

2. JAVA的用途和特性

Java的用处：
开发桌面应用程序
-银行软件、商场结算软件
开发面向 Internet 的 web 应用程序

-门户网站(工商银行)、网上商城、阿里巴巴、电子商务网站
提供各行业的解决方案

-金融、电信、电力...
嵌入式开发

Java 的特性：
一种纯面向对象的编程语言。

一种与平台无关(跨平台)的语言。(它提供了在不同平台下运行的解释环境)

一种健壮的语言，吸收了 C/C++语言的优点。

有较高的安全性

JAVA 代码语句分类：

结构定义语句：对代码进行结构划分

功能执行语句：执行相应功能的语句（必须以;结尾）

3. JAVA 跨平台原理

两种核心机制：

1. Java 虚拟机(Java Virtual Machine)

- 它有一个解释器组件，可以实现Java字节码和计算机操作系统之间的通信

- 对于不同的运行平台，有不同的 JVM

2. JVM 垃圾回收器(Garbage Collection) GC

        - 不再使用的内存空间应当进行回收-垃圾回收。
        - 在 C/C++等语言中，由程序员负责回收无用内存。
        - Java 语言消除了程序员回收无用内存空间的责任:
        - JVM 提供了一种系统线程跟踪存储空间的分配情况。并在 JVM 的空闲时，检查并释放那些可以被释放的存储空间。垃圾回收器在 Java 程序运行过程中自动启用，程序员无法精确控制和干预

4. JAVA SE 组成

JDK(Java Development Kits)-- Java 开发工具集

JRE(JavaRuntimeEnvironment)Java运行时环境

- VM
- Java API (应用程序编程接口)

Java 编译器(javac.exe)、Java 运行时解释器(java.exe)、Java 文档化化工具(javadoc.exe)及其它工具及资源
- JRE 的三项主要功能:

                 加载代码:由类加载器(classloader)完成;
                 校验代码:由字节码校验器(bytecodeverifier)完成;
                 执行代码:由运行时解释器(runtimeinterpreter)完成。

5. 工具下载（JDK11 & Eclipse）Mac版

JDK

1. 检查电脑是否已有JAVA

打开terminal.app -> 输入 java -version

2. 如果不是想要的版本可以先卸载后下载

-- cd /Library/Java/JavaVirtualMachines

-- sudo rm -rf 【版本名称】

3. 进入JDK下载网址：Oracle官网

下载相应版本后根据安装向导进行安装后：

4. 打开terminal.app -> 输入 java -version -> 提示java版本号及相关信息

Eclipse

Eclipse 是一个开放源代码的、基于 Java 的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境

1. 下载地址：Eclipse官网

2. 找到Download，下载后根据安装向导操作

第二节

1. 二进制

二进制:逢二进一

十进制：10 二进制： 1010

计算过程： $1*2^{4-1}+0*2^{3-1}+1*2^{2-1}+0*2^{1-1} = 10$

八进制和十六进制同理但是在十六进制中用A-F 表示10-15

计算机中信息的存储单位
位(Bit):表示一个二进制数码 0 或 1，是计算机存储处理信息的最基本的单位。

字节(Byte):一个字节由 8 个位组成。它表示作为一个完整处理单位的 8 个二进制数码。因此最大的字节为1111 1111（换算成十进制为255）

2. 补码

计算机内的二进制数值是以补码形式表示的。

正数的补码：与其原码的形式是相同的。
负数的补码: 将该数的绝对值的二进制形式，按位取反再加 1

例如：

（1）

原码 10 = 00000000 00000000 00000000 00001010

补码 10 = 00000000 00000000 00000000 00001010

（2）最后4位 1010 取反 0101 ，再加1为0110

原码 -10 = 10000000 00000000 00000000 00001010

补码 10 = 11111111 11111111 11111111 11110110

3. 数据类型

按所属的数据类型划分:

1. 基本数据类型变量
2. 引用数据类型变量

按被声明的位置划分:

1. 局部变量:方法或语句块内部定义的变量

2. 成员变量:方法外部、类的内部定义的变量

public static void main(String[] args){
	// 直接写出的浮点数是double类型，需要强制转换
    float f1 = 1.4f;
	// 直接写出的证型数是int类型，过大会出错需要转换为long
    long l1 = 1000000000l;
    // char 字符型属于数值，可以加减（参考ascii表）
	char c1  =  'A';
	System.out.println(++a);// 输出结果为B
}

3. 逻辑运算符

public static void main(String[] args) {
    int i = 10;
    // 结果输出自增1后的值 11
    System.out.println(++i);
    // 结果输出自增1前的值 11
    System.out.println(i++);
    // & 左右两边需要同时true
    System.out.println(2 >= 2 & 1 <= 2);//true
    // | 左右任意一个为true则为true
    System.out.println(2 <= 2 | 2 <= 1);//true
    // ^ 左右结果不同则为true
    System.out.println(2 >= 2 ^ 1 <= 2);//false
    // && 与&的意义一样但是如果左边为true则不计算符号右边
    int j = 0;
    // 这种写法会报错：0作为分母
    System.out.println(1/j > 1+2);
    // 用&&做判断避免报错
    System.out.println(j!=0 && 1/j > 1+2);//false
    // 与&&相类似的，使用||时，当左边表达式为true时则为true不用计算右边
 }

4. 三目(三元)运算符

判断？表达式1 ：表达式2

当【判断】为true时，则计算表达式1，否则计算表达式2

public static void main(String[] args) {
        // 三目运算符
        int a = 10;
        int b = 20;
        // 如果a>b,则max = a，否则max = b
        int max = a > b ? a : b;
        System.out.println("max:" + max);// max: 20
    }

第三节

1. 接收用户输入

package com.test;

// 调用Scanner包
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // System.in 输入
        Scanner input = new Scanner(System.in);
        // 一般在需要输入前，进行提示
        System.out.println("请输入3位数整数： ");
        // 接收各类型数据
        int i = input.nextInt();//必须接收int类型,如果输入其他类型数会报错
        System.out.println(i);
        // 因此一般使用next和nextLine去接收字符串形式的输入
        // 区别：next 接收不到空格及空格后的输入（开头的空格不算）
        System.out.println("请输入任意内容： ");
        String str1 = input.next();
        System.out.println(str1);
        /*
        String str2 = input.nextLine();
        System.out.println(str2);
        next 和 nextLine一般不一起用
         */
    }
}

2. 条件判断语句

1. If语句

package com.test;
import java.util.Scanner;

public class IfDemo {
	/**
	 * 1. if(){} else{}  如果()就{}否则{}
	 * 2. if(){} else if(){} else{}  如果()就{},如果()就{},否则{} */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入数字判断奇偶：");
		int i = input.nextInt();
		if(i > 1000 | i<0) {
			System.out.print("我不会:(");
		} else if(i%2 == 0){
			System.out.print("偶数！");
		} else{
			System.out.println("奇数！");
		}
	}
}

2. Switch语句

package com.test;
import java.util.Scanner;
public class SwitchDemo {
	/**
	 switch(表达式){
	 case 取值 1: 语句块 1; break;
	 		.
	 		.
	 		.
	 case 取值 n: 语句块 n; break;
	 default: 语句块 n+1;break;
	 }
	 */
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		System.out.println("请输入今天星期几: ");
		int i = input.nextInt();
		switch(i){
			// case后同样的结果可以省略break
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("今天星期"+i+",上班！");
				// 通过break 跳出switch
				break;
			case 6:
				System.out.println("今天星期"+i+",睡觉！");
				break;
			case 7:
				System.out.println("今天星期"+i+",逛街！");
				break;
			// default可有可无
			default :
				System.out.println("您输入有误!(提示：1-7)");
				break;
		}
	}
}

3. 循环语句

1. For循环语句

package com.test;

public class ForDemo {

	public static void main(String[] args) {
		int count = 0;
        // 格式1:  定义i；判断i；更新i
		for(int i=0;i<10;i++) {
			for(int j=0;j<10;j++) {
				count++;
				System.out.println(count);//从1输出到100
			}
		}
	}
}

2. While循环语句

package com.test;
import java.util.Scanner;

public class WhileDemo {
	/**
	 * while(条件表达式){
	 *     语句
	 * }
	 * 输入裁判人数及所打分数，计算选手平均分
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入裁判人数：");
		int i = input.nextInt();
		int count = 0;
		int score;
		int ScoreSum = 0;
		int ScoreAvg;
		while(count<i){
			count++;
			System.out.println("输入第"+count+"位裁判的分数：");
			score = input.nextInt();
			ScoreSum+=score;
		}
        /* do{
		count++;
		System.out.println("输入第"+count+"位裁判的分数：");
		score = input.nextInt();
		ScoreSum+=score;
		} while(count<i); */
		ScoreAvg = ScoreSum / i;
		System.out.println("选手的平均分数："+ScoreAvg);
	}
}

* while的另一种用法是do{} while(),与while的用法差不多

do{
循环操作
}while( 条件表达式 );

区别：do while先执行一遍循环操作，然后再判读条件，如果条件满足，继续执行循环操作。

3. continue 和 break的用法及区别

package com.test;

public class ForDemo {

	public static void main(String[] args) {
		for(int i=0;i<10;i++) {
			// continue 当i等于3时，结束这一次循环，继续i++
			if(i==3){
				continue;
			// break 当i等于6时，结束整个循环	
			} else if(i == 6){
				break;
			}
			System.out.println(i);//输出结果：0 1 2 4 5
		}
	}
}

在多重循环时，想跳出整个循环，可以在for 前给循环取别名再break

package com.test;

public class ForDemo {

	public static void main(String[] args) {
		FirstSum:for(int i=0;i<5;i++) {
			for(int j=0;j<5;j++) {
				System.out.println(i+" "+j);
				if(i==3 && j ==2){
					/*
					直接用break，只跳出了内部这一次循环（只会跳过i等于3，j>2后的组合）
					break;
					*/
					// 给循环取名位为FirstSum直接跳出整个循环
					break FirstSum;
				}
			}
		}
	}
}

第四节

1. 数组

package com.test;
import java.util.Scanner;

public class ArrayDemo{
	public static void main(String[] args) {
		// 新定义一个数组，并赋值
		int[] array1 = {1,2,3,4,5};
		System.out.println(array1[2]);//3
		// 新定义一个数组，定义长度为5
		int[] array2 =new int[5];
		// 通过给数组指定位置赋值
		array2[0] = 1;
		System.out.println(array2[0]);//1
		// array.length获取数组长度
		for(int index=0;index<array1.length;index++){
			System.out.println(array1[index]);//1,2,3,4,5
		}

	}
}

2. 冒泡排序

冒泡排序：
   -- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
   --对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
   -- 针对所有的元素重复以上的步骤，除了最后一个。
   -- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

package com.test;
import java.util.Scanner;
public class BubbleSort {
	/**
	 * 冒泡排序：
	 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
	 * 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的
	 数。
	 * 针对所有的元素重复以上的步骤，除了最后一个。
	 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
	 */
	public static void main(String[] args){
		int[] arr = {11,22,44,33,66,55};
		int tmp;
		//首先begin分别与arr1[1][2][3][4][5]比较5次，剔除最大后比较4次...,
		// 外层循环控制比较轮数：length-1
		for(int i=0;i<arr.length-1;i++){
			//11需要和后面5个数比较，最大66放在arr1[6]；22比较4次后，最大55放在arr1[5]
			//内层控制每轮比较的次数：lenth-i-1
			for(int j = 0;j<arr.length-i-1;j++){
				// 互相比较，前面大于后面就通过第三方变量进行移动
				if(arr[j]>arr[j+1]){
					tmp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
				}
			}
		}
		// 查看重新排序后的结果
		for(int k=0;k<arr.length;k++){
			System.out.println(arr[k]);
		}
	}

}

3. 二分查找

二分查找也称折半查找(Binary Search)：
-- 首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功;否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查找后子数组。
-- 重复以上过程，直到找到满足条件的数据，则表示查找成功，直到子数组不存在为止，表示查找不成功

package com.test;
import java.util.Scanner;
public class BinarySearch {
	/**
	 * 二分查找也称折半查找(Binary Search)：
	 *   首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功;否则利用
	 * 中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查
	 * 找后子数组。
	 * 重复以上过程，直到找到满足条件的数据，则表示查找成功，
	 * 直到子数组不存在为止，表示查找不成功
	 */
	public static void main(String[] args){
		// 该数组必须是有序排列（如果不是有序需要先排序）
		int[] arr = {11,22,33,44,55,66,77,88,90};
		Scanner input = new Scanner(System.in);
		System.out.println("输入想要搜索的数字：");
		int num = input.nextInt();
		//关键的三个因素
		//1. 最小范围下标
		int minIndex = 0;
		//2. 最大范围下标
		int maxIndex = arr.length-1;
		//3. 中间数据下标
		int midIndex = (minIndex+maxIndex)/2;
		// 循环的轮数不清楚，用while。直到完成再break跳出
		while(true){
			if(arr[midIndex]>num){
				//中间数据大，最大下标=中间数据下标-1
				maxIndex = midIndex-1;
			}else if(arr[midIndex]<num){
				//中间数据小，最小下标=中间数据下标+1
				minIndex = midIndex+1;
			}else{
				//找到了数据 数据位置为minIndex
				break;
			}
			// 如果最小下标大于最大下标,说明没找到该数据
			if(minIndex>maxIndex){
				midIndex = -1;
				break;
			}
			// 当边界发生变化，需要更新中间下标
			midIndex = (minIndex+maxIndex)/2;
		}
		// 查看重新排序后的结果
		if(midIndex>=0){
			System.out.println("数据位置在："+midIndex);
		}else{
			System.out.println("数据未找到");
		}

	}

}

Guangshan Hu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础笔记

目录第一节1. JAVA起源及演变2. JAVA的用途和特性3. JAVA 跨平台原理4. JAVA SE 组成5. 工具下载（JDK11 & Eclipse）Mac版JDKEclipse第一节1. JAVA起源及演变1991 年，SUN公司的詹姆斯·高斯林(James Gosling)领导项目小组（名为“Green”）开发一种能够在各种消费性电子产品上运行的程序架构，在1992年创作了面向对象语言‘’OaK“，1994年用其研发了Ap...
复制链接

扫一扫