Java是一种跨平台的、面向对象的编程语言。广泛应用于应用开发、Web 开发等众多领域。
在 Java 中，万物皆为对象（数值型和 char 不是，但它有相应的包装类，这些包装类是对象）
String 是对象，数组是对象，类是对象，集合类 (如 ArrayList、HashSet 等) 是对象 ...
使用 new 关键字创建对象，并为其分配空间 (数组还能指定大小)，并调用构造方法初始化对象。
package 语句：声明当前代码所属的包名，不是文件夹名。
import 语句：引入某类，然后在当前代码中就能直接使用这些类了。
格式：import 包名.类名（从上述的 package 语句的包名开始，直到类名为止）
主方法：public static void main(String[] args){ ... }
键盘输入：引入类：import java.util.Scanner;
使用类：Scanner input = new Scanner(System.in);
整数用 input.nextInt(); 小数用 input.nextDouble(); 字符串用 input.next();
输出打印：System.out.println("Hello World"); // 带 In 则带换行
一、基础篇：
1、代码规范
Java 与 C、C++、C#、JavaScript 等语言的风格规范基本相同。
（1）注释：// 单行注释 、/* 多行注释 */
（2）语句以分号结束
（3）程序块以{}划出范围
（4）用类型与名称来声明变量
（5）把 boolean 测试放在括号中
2、运算符
（1）算数运算符：+
（2）比较运算符：==
（3）逻辑运算符
（4）赋值运算符：=
（5）三元运算符
（6）位运算
（7）运算优先级
3、流程控制
（1）条件语句
1、if 条件语句
a、单向条件语句
b、双向判断语句 or 三元运算符
c、多向判断语句
2、switch 条件语句
（2）循环语句
1、while 循环
2、do...while 循环
3、for 循环
（3）跳转语句
1、break 语句
2、continue 语句
4、变量 & 数据类型 (正式开始)
（1）变量：对象的代名词
1、声明：由类型名和变量名组成。
2、命名：不以数字开头，不能与关键字与标识符同名。
3、作用域：取决于变量声明的位置（实例变量、static 类变量、函数局部变量）
（2）基本数据类型：
数值型：
1、int 整型（byte、short、long）
2、double 浮点型（float）
3、boolean 布尔型
非数值型：
1、char 单字符 （单引号）
2、String 字符串（双引号）
示例：int a = 10，double b = 9.9，boolean c = true，char d = 'W'，String d = "程序员"；
（3）类型转换：
1、自动类型转换（升阶）：byte, short, char —> int —> long —> float —> double
2、强制类型转换（降阶）：如 int(10.98)：将 10.98 转换为 10
5、数组类 & Arrays 类
在内存中开辟的一串连续的空间，用来存储 相同数据类型 的数据，数组下标从 0 开始。
包含：字符串数组、整型数组、浮点型数组、布尔数组、字符数组、对象数组...
数组名表示数组首个元素的地址，即 &arry[0] ；而 arry[0] 表示第一个元素，而非地址。
（1）定义数组
1、new 一个：double[] myList = new double[size]; myList[0] = 5.6; ......
2、直接声明 ：double[] myList = = ["Saab" , "Volvo" , "BMW"];
（4）使用数组
1、对象数组：Person[] persons = { new Person("Alice", 25), new Person("Bob", 30) };
2、For-Each 循环：for(type element : array){ System.out.println(element); }
3、数组与函数
作参数：public static void printArray(int[] array) { ... } 调用：printArray(arr);
作返回值：先要定义：int[] result = new int[list.length]; 返回：return result;
4、多维数组 (二维为例)：数组的数组：type[typeLength1][typeLength2]
（3）Arrays 类：java.util.Arrays 类能操作数组，它提供的所有方法都是静态的。
功能包括：给数组赋值、排序、比较，查找数组元素。
6、类与对象
Java 作为一种面向对象的编程语言，支持面向对象的所有特性，万物皆为对象。
（1）类与对象
1、类：对象的模板，拥有所有对象的共同特征和属性（抽象）
2、对象：具体的个体，拥有一组属性和方法的集合（具体）
3、属性：描述对象特性的数据，即若干变量。
4、方法：操作对象的若干动作，即若干函数。
static 修饰的 变量/方法，只此一份，被所有对象共享，可以直接通过类名调用。
（2）定义类：class class_name{ 成员变量 (属性) + 构造方法 + 成员方法 }
this 代表当前对象。this.x = x , 表示把方法参数的值 (局部变量) 赋给当前对象的成员变量
public class Student {
private String name; // 成员变量（属性）
public Student(String name, int age) { // 构造方法
this.name = name;
}
public void showInfo() { // 成员方法
System.out.println("姓名: " + name "); }}
（3）使用类： 先 new 一个对象：class_name object_name = new class_name()；
再通过“.”操作符，使用这个对象的属性和方法
（4）继承类：class Child_name extends Parent_name { ... }
1、子类可以直接使用父类的非私有属性和方法（使用 super 关键字）
2、子类可以重写父类的方法，以实现更具体或不同的行为。
（5）封装类：private 标记属性私有 ，并提供 public的公共方法来访问和修改这些属性。
private int age;
public String getAge(){ return age; }
public void setAge(int age){ this.age = age; }
7、类的方法
Java 中的方法是一段被命名的、用于完成特定任务的代码块。与 C 的函数相似，但也有区别 :
1、Java 支持方法重载，即可以有多个同名但参数不同的方法。
2、方法通常是在类中定义的，与对象和类的概念紧密结合。
（1）定义方法：访问修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return... }
1、访问修饰符：public 公共的-最高级别
2、返回值类型：无则用 void；有则添加 return，根据实际返回的类型，去修改返回值类型
3、参数可选，且该参数为形参 (局部变量)
（2）调用方法：参数严格对应
1、调实例方法：先 new 一个类的对象，再用对象来调用实例方法。
2、调静态方法：直接使用类名来调用静态方法，无需创建对象。
8、包装类 & Math 类
Java 为每个基本数据类型都提供了对应的包装类，即能用 new 的方式定义数字对象（变量）
包装类：Integer 对 int、Long 对 long、Double 对 double、character 对 char ......
实际开发中，对于包装类，更多时候会使用自动装/拆箱的特性（示例如下）
（1）定义数字：Integer x = new Integer(10) —> Integer x = 10
（2）Math 类 ：包含了执行基本数学运算的属性和方法，可以通过 Math 在主函数中直接调用。
含数学函数、三角函数、随机函数、数学常量（圆周率、自然常数），参考 Java Math 类
9、String 类 & StringBuffer 类
字符串是一个不可变的字符序列。如果对字符串进行操作，实际上会创建一个新的字符串对象。
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类（不产生新的对象）
（1）定义字符串：
1、直接定义：String b = "程序员";
2、new一个：String b = new String("程序员"); // 使用对象的方式
（2）使用字符串：
1、拼接：字符串 + 数字 = 字符串（先转换为串，再做拼接。都是字符串，才能拼接）
2、格式化：
a、帮忙占位：使用 "%s", "%d", "%f" 帮变量占位，再在串后面加上 变量
示例：System.out.printf("浮点型变量的值 " + "is %f", floatVar);
b、表达式格式化：把上述变量替换为表达式即可
3、类的方法：参考 Java String 方法
（3）StringBuffer 类：每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象。
类的方法：参考 Java StringBuffer 类
10、枚举类
Java 枚举是一个特殊的类，一般表示一组常量，使用 enum 关键字来定义。
（1）定义枚举：enum Color{ RED, GREEN, BLUE; }
（2）使用枚举：
1、赋值：Color c1 = Color.RED;
2、遍历：for(Color myVar : Color.values()){ ... }
3、在 switch 语句中：switch (myVar){
case RED;
System.out.println("红色");break; ...}
二、进阶篇：
以下都是一些集合类（ArrayList 类、HashSet 类、HashMap 类...），这些类都是对象。
1、ArrayList 类
ArrayList 是一个可以动态修改的数组，没有固定大小的限制，这是与普通数组最大的区别。
（1）引入类：import java.util.ArrayList;
类的方法：参考 Java ArrayList 类
（2）使用类：ArrayList<E> object_name = new ArrayList<>(); // E为泛型 (String/包装类/...)
2、HashSet 类
HashSet 是基于 HashMap 来实现的，是一个无重复元素、无序、允许存在 null 值的集合。
（1）引入类：import java.util.HashSet;
类的方法：参考 Java HashSet 类
（2）使用类：HashSet<E> object_name = new HashSet<E>();
3、HashMap 类
HashMap 是一个散列表，它存储的内容是键值对（key-value）映射，无序。
其中，key 与 value 数据类型可以相同，也可以不同。
（1）引入类：import java.util.HashMap;
类的方法：参考 Java HashMap 类
（2）使用类：HashMap<E1, E2> object_name = new HashMap<E1, E2>();
4、Iterator 迭代器
迭代器 Iterator 是一种用于单向遍历集合的接口方法（替代 for 循环或索引）
只能从前往后遍历，单向一次性。遍历时，只能用迭代器的 remove() 方法来删除当前元素。
（1）引入类：import java.util.Iterator;
类的方法：1、next() - 返回迭代器的下一个元素，并将迭代器的指针移到下一个位置
2、hasNext() - 用于判断集合中是否还有下一个元素可以访问
3、remove() - 从集合中删除迭代器最后访问的元素（可选操作）
（2）使用类：
1、获取迭代器：Iterator<E> it = object_name.iterator();
2、循环集合元素：while(it.hasNext()){ ... }
2、接口
接口 Interface 是一种特殊的抽象类型。接口定义了一组抽象方法和常量（默认是 public static final 修饰的）。接口中的方法只有方法签名，没有方法体。接口可以继承其他接口。
1、类可以使用 implements 关键字实现一个或多个接口
2、类可以通过实现接口来实现多态，该类提供接口中所有抽象方法的不同的具体实现
（1）定义接口：[可见度] interface 接口名称 [extends 其他的接口名]{ // 声明变量 // 抽象方法 }
（2）使用接口：...class... implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...
（3）继承接口：public interface child_name extends parent_name01, parent_name02
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
