Java
一、了解
1.Java特性和优势
-
简单性
-
面向对象：万物皆可对象
-
可移植性：跨平台移植（核心JVM，通过JVM屏蔽了底层的差别），写一次编译到处运行
-
高性能：集成编译
-
分布式：可以处理TCP IP问题，可以通过网络调用
-
动态性：反射机制
-
多线程：交互性、实时性；可以同时做
-
安全性：Java有异常机制，可以捕获异常
-
健壮性
2.Java版本
-
JavaSE：标准版（桌面程序，控制台开发..）
-
JavaEE：企业级开发（web端、服务器端开发..）
3.JDK、JRE、JVM
-
JDK：Java Development Kit（Java开发者工具：在JRE基础上扩充开发工具；做开发必须安装JDK；因此下一个JDK就OK了！）
-
JRE：Java Runtime Environment（Java运行时环境：只要安装JRE就可以运行Java程序）
-
JVM：Java Virtual Machine（Java虚拟机：在操作系统上模拟了小巧CPU处理Java程序）
4.使用记事本写Java，并编译运行
-
编译：
javac Hello.java
-
运行
java Hello
5.Java程序运行机制
-
编译型（类似于翻译：将Java转换为计算机可以识别的；速度更快）
-
解释型（执行哪一句就执行哪一句）
二、Java基础语法
1.IDEA快捷键
psvm //main()函数 sout //输出
2.标识符
-
标识符是大小写敏感的
-
所有标识符都应该以字母，美元符($)，下划线开始
-
首字符之后可以是以字母，美元符($)，下划线或数字
-
不能使用关键字作为变量名或方法名
合法标识符：age、$salary、_value 非法标识符：123abc、-salary、#abc
3.关键字
Java所有的组成部分都需要名字。
类名、变量名以及方法名都被称为标识符
4.数据类型
强类型语言：所有变量必须先定义后使用
定义：类型 变量名=初始值；
-
基本数据类型
-
引用数据类型：类、接口、数组、String
5.类型转换
运算中，不同类型的数据先转化为同一类型，然后进行运算
-
强制转换：从高到低（类型名）变量名
-
自动转换：从低到高
注意：不能对布尔值进行转换；转换的时候可能存在内存溢出或精度问题
6.变量作用域
-
类变量：static（标识）；方法之外，类之内；从属于类，生命周期伴随类始终；可以不用初始化
public class Demo02 {
static double salary = 2500;
public static void main(String[] args) {
System.out.println(salary);//可以直接引用，不用创建对象引用；
}
}
-
实例变量：方法之外，类之内；从属于对象，生命周期伴随对象始终；可以不用初始化
public class Demo02 {
//布尔值默认值是false;除了基本类型其余默认值是null
String name;//默认值是null
int age;//默认值是0
public static void main(String[] args) {
//变量类型 变量名字 = new Demo02();自己得到自己
Demo02 demo02 = new Demo02();
System.out.println(demo02.age);//0
System.out.println(demo02.name);//null
}
}
-
局部变量：必须初始化值；生命范围在方法的两个大括号之内，括号之外不是作用范围。
7.常量
-
常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。 程序中使用常量可以提高代码的可维护性。
-
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
-
常量名一般使用大写字符。
//final 常量名=值;
//static和final是修饰符，不存在先后顺序。
public class Demo02 {
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
8.命名规则
-
局部变量、方法名、类成员变量：第一个单词首字母小写，后面单词首字母大写；monthSalary、run()
-
常量：大写字母和下划线；MAX_VALUE
-
类名：首字母大写；Man、DoodMan
9.运算符
-
关系运算符：>，<，>=，<=，==，!= instanceof
结果：布尔值
注意：关系运算符通常和if、else一起使用
-
一元运算符：一个变量
i++；++i
i--；--i
-
幂运算
//和数学相关：Math double pow = Math.pow(2,3)//2的三次方
-
三元运算符：
return a>b?a:b//如果a>b是true,那么返回a;否则返回b
10.JavaDoc
-
JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API，易读且清晰明了。
cmd-对应目录 -encoding UTF-8 -charset UTF-8 //解决GBK乱码问题，在中间添加编码设置
-
以 /* 开始，以 / 结束。
@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
11.转义字符
\t：空格
\n：换行
System.out.print(i+"\t");//和双引号搭配
三、Java流程控制
1.Scanner对象
-
java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的 输入。
//创建 Scanner 对象的基本语法 Scanner s = new Scanner(System.in);
-
通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符 串，在读取前我们一般需要 使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据。
Scanner scanner = new Scanner(System.in);//创建一个扫描器对象，用于接收键盘数据
//判断用户有没有输入字符串
System.out.println("使用next方式接收：");
if (scanner.hasNext()){//true，判断是否有输入
String str1 = scanner.next();//获取键盘输入的数据，程序会等待用户输入完毕（Enter）
System.out.println("输入的值str1："+str1);
}
scanner.close();//是属于IO流的类,要进行关闭，如果不关闭会一直占用资源
}
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收：");
if (scanner.hasNextLine()){
String str2 = scanner.nextLine();
System.out.println("输入的值str2:"+str2);
}
scanner.close();
//依次输入多个数据
double sum = 0;
int m = 0;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入：");
//通过循环判断是否还有输入；当条件不成立跳出循环（可以输入字母结束（不是数字））
while (scanner.hasNextDouble()){
m = m + 1;
sum = sum + scanner.nextDouble();
System.out.println("你输入的是第"+m+"个数,sum的值为："+sum);
}
scanner.close();
}
-
next()和nextLine()的区别
①next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。
②nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
2.选择结构
-
if选择结构
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}
else{
//false
}
equals()//判断字符串相等，不能用==
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
-
switch选择结构：多选择结构
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
switch(expression){
case value :
//语句
break; //跳出，下面的分支不执行
case value :
//语句
break; //跳出
//你可以有任意数量的case语句
default : //可选
//语句
}
①变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现 才会跳出 switch 语句。 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。
②case 语句不必 须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句
③switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何 位置，但建议在最后一个。
default 在没有 case 语句的值和变量值相等的时候执行。default 分 支不需要 break 语句。
3.循环结构
-
while循环
while( 布尔表达式 ) {
//循环内容
}
大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影 响程序性能或者造成程序卡死奔溃！
-
do-while
do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
-
for
for 循环，使一 些循环结构变得更加简单。
for(初始化; 布尔表达式; 更新) {
//代码语句
}
for(;;){
//死循环
}
public class Circulate {
public static void main(String[] args) {
//输出1-1000能被5整除的数,每行输出三个
int k = 1;
for (int i=1;i<=1000;i++){
if (i%5==0){
if ((k%3)!=0){
System.out.print(i+"\t");
k++;
}
else{
System.out.print(i+"\n");
k++;
}
}
}
}
}
//打印99乘法表
public class Multiplication {
public static void main(String[] args) {
for (int j=1;j<=9;j++){
for (int i=1;i<=j;i++){
System.out.print(i+"*"+j+"="+(i*j)+"\t");
}
System.out.println();
}
}
}
-
增强for循环
主要用于数组或集合的增强型 for 循环。
①声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句 块，其值与此时数组元素的值相等。
②表达式：表达式是要访问的数组名，或者是返回值为数组的方法
for(声明语句 : 表达式)
{
//代码句子
}
public static void main(String[] args) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
4.break和continue
-
break 主要用在循环语句或者 switch 语句中，强行跳出循环，不执行循环剩余语句。 break 跳出最里层的循环，并且继续执行该循环下面的语句。
-
continue用于终止某次循环过程 ，即跳出尚未执行的循环，继续下一次是否循环的判定。 在 for 循环中，continue 语句使程序立即跳转到更新语句。 在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
四、方法
-
方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最 好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展。
-
方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需 的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。
参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。 形式参数：在方法被调用时用于接收外界输入的数据。 实参：调用方法时实际传给方法的数据。
return 只能放在最下面
方法的重载：在一个类中，有相同的函数名称，但形参不同的函数
五、数组
-
数组索引从0开始
获取数组长度：数组名.length
//定义
int[] num;//声明一个数组
num = new int[10];//创建
//给数组元素赋值
num[0] = 1;
num[1] = 2;//没有赋值，默认int型为0
//获取数组长度:num.length
//计算所有元素之和
public static void main(String[] args) {
int[] num;
num = new int[6];
num[0] = 1;
num[1] = 2;
num[2] = 3;
num[3] = 4;
num[4] = 5;
num[5] = 6;
System.out.println(num[0]);
int sum = 0;
for (int i=0;i<num.length;i++){//i从0开始
sum = sum + num[i];
}
System.out.println(sum);
}
-
报错：数组下标越界异常
-
数组初始化方式：
//静态初始化：创建＋赋值
int[] arr = {0,1,2,3};
//动态初始化
int[] num = new int[10];//数组包含默认值
num[0] = 1;
public class Total {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
printArr(arr);
System.out.println("==========");
int[] result = reverseArr(arr);
printArr(result);
}
//打印数组
public static void printArr(int[] arr){
for (int i=0;i< arr.length;i++){
System.out.println(arr[i]);
}
}
//反转数组
public static int[] reverseArr(int[] arr){
int[] reverse = new int[arr.length];
for (int i=0,j= reverse.length-1;i< arr.length;i++,j--){
reverse[j] = arr[i];
}
return reverse;
}
}
-
二维数组
int[][] array = {{1,2},{3,4},{5,6}};//3行2列的数组
array.length：外层几个数 array[0].length：内层几个数
public static void printArray(int[][] array){//打印二维数组
for (int i=0;i<array.length;i++){
for (int j=0;j<array[i].length;j++){
System.out.println(array[i][j]);
}
}
}
-
Arrays
-
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对 象来调用(注意:是"不用" 而不是 "不能")
-
java.util.Arrays 类能方便地操作数组. 使用之前需要导包！
-
具有以下常用功能：
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
-
public static void main(String[] args) {
int[] arr = {1,3,2,8,4,5};
System.out.println("这是排序前：");
System.out.println(Arrays.toString(arr));//打印数组Arrays.toString(arr)
System.out.println("这是排序后：");
Arrays.sort(arr);//对数组进行排序
System.out.println(Arrays.toString(arr));
}
public static void main(String[] args) {
int[] a = {1,2,323,23,543,12,59};
Arrays.sort(a); //使用二分法查找，必须先对数组进行排序
System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
}
public static void main(String[] args) {
int[] a = {1,2,323,23,543,12,59};
Arrays.sort(a); //使用二分法查找，必须先对数组进行排序
Arrays.fill(a, 2, 4, 100); //将2到4索引的元素替换为100
System.out.println(Arrays.toString(a));
}
六、冒泡排序
冒泡排序算法的原理如下：
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会 是最大的 数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
七、面向对象：OOP（Object-Oriented Programming）
-
面向过程&面向对象
①面向过程：适合较简单的问题，步骤清晰：第一步做什么、第二步做什么，步骤明确
②面向对象：分类的思维模式，
-
①方法调用：
-
静态方法：static；类存在的时候静态方法就存在
类名.方法
-
非静态方法：类实例化之后才存在
实例化方法：new 类().方法;
②方法调用：同一个类
-
两个都是静态方法，可以互相调用。
public class Function { public static void main(String[] args) { } public static void a(){ b(); } private static void b() { } } 🐖报错：
-
③两个类：
一个类：private
另一个主类：就不能对象.属性或方法
解决方案：
-
类：抽象的数据类型，是对某一类事物整体描述/定义，但并不能代表某一个具体事物（人）
对象：是抽象概念的具体实例（张三）
-
注意：不用每个类都加main
一个项目只存在一个主函数（测试类）
-
类包含：属性+方法
八、构造器
1.类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下特点：
-
必须和类名相同
-
必须没有返回值类型，也不能写void
-
定义有参构造，就必须有无参构造（不能省略）
public class Person{
public Person(){}
}
2.构造器的作用：
-
实例化初始值
-
使用new关键字，必须要有构造器；new对象本质是调用构造器
生成构造器：Alt+insert
扫一扫
3518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
