基本知识点
- 文件名必须和类型一致,类名首字母要大写,例如:
MyClass
注释-Commonts
- Java 注释(Java Comments),单行注释
//
,在//
至当前行行位之间的内容,都会被忽略 - 多行注释:
/*
被注释的内容*/
,
变量-Variables
String
存储文本,例如 "hello",用双引号包含值char
存储单个字符(character),例如 "B",用双硬汉包含值int
存储没有小数点的整数,例如 "123" "-123"float
存储浮点数,有小数点的,例如 "19.99" "-19.99"boolean
存储布尔值,有两个状态:true
或false
- 声明变量的语法:
type variable = value;
,例如:String name = "Michael;"
boolean myBool = true;
float myFloatNum = 5.99f; // floating point number
- 同时声明多个同类型的变量
int x =5, y = 6;
- 必须使用唯一名称标识所有Java变量,这些唯一名称称为标识符(identifiers)。变量名有一些规范:
- 变量名可以包含字母、数字、下划线、
$
符号 - 变量名可以
$
、_
、字母开头 - 变量名建议小写字母开头,不能包含空格
- 「保留字」不能作为变量名
- 变量名可以包含字母、数字、下划线、
数据类型-Data Types
数据类型分为两组:
- 原始数据类型(Primitive data types):
byte
,short
,int
,long
,float
,double
,boolean
andchar
- 数字
Integer types
整形数字,没有小数点byte
字节 =8 bit
位,-128 to 127,例:byte myNum = 100;
short
=2 bytes
-32,768 to 32,767,例:short myNum = 5000;
int
=4 bytes
,int
类型是我们首选的数字类型,例:int myNum = 100000;
long
=8 bytes
,应该要以L
结尾,例:long myNum = 15000000000L;
Floating point types
浮点数类型float
=4 bytes
,应该要以f
结尾,例:float myNum = 5.75f;
double
=8 bytes
,在大多数计算中使用double更安全,应该要以d
结尾,例:double myNum = 19.99d;
boolean
=1 byte
存储值只能是true
orfalse
,例:boolean isJavaFun = true;
char
=2 bytes
存储单个字符(character)或字母(letter),char
值必须用单引号括起来例,char myGrade = 'B';
String
类型的值必须是以双引号括起来,例:String greeting = "Hello World";
- 非原始数据类型(Non-primitive data types):例如
String
,Arrays
andClasses
- 非原始数据类型称为「引用类型」,因为他们引用「objects」。它们和原始数据类型的区别在:
- 原始类型是 Java 中预定义的。非原始类型是由程序员定义的(除了
String
)。 - 非基本类型可用于调用方法来执行某些操作,而基本类型不行。
- 基本类型始终有值,而非基本类型可以为
null
。 - 基本类型以小写字母开头,而非基本类型以大写开头。
- 非基本类型包含
String
,Arrays
,Classes
,Interface
,etc
- 原始类型是 Java 中预定义的。非原始类型是由程序员定义的(除了
泛型
泛型是Java SE 1.5 的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。
public class Box<T> {
private T object;
public void set(T object) { this.object = object; }
public T get() { return object; }
}
创建一个Box对象,带泛型参数,获取对象的时候就不需要强制转换
Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();
总结下泛型的好处就是:省去了强制转换,可以在编译时候检查类型安全,可以用在类,方法,接口上
下来说说泛型通配符T,E,K,V区别
这些全都属于java泛型的通配符,刚开始我看到这么多通配符,一下晕了,这几个其实没什么区别,只不过是一个约定好的代码,也就是说
使用大写字母 A,B,C,D......X,Y,Z
定义的,就都是泛型,把 T
换成 A
也一样,这里 T
只是名字上的意义而已
?
表示不确定的java类型T (type)
表示具体的一个java类型K V (key value)
分别代表 java 键值中的Key Value
E (element)
代表Element
参考:
Strings
String Length
,例:String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";int len = txt.length();
toUpperCase()、toLowerCase()
方法,将值变为全大写、全小写indexOs()
返回在字符串中第一次出现的索引位置,和 Python 一样,也是从 0 开始的;+
操作符可以字符串连接(concatenation);concat()
方法也可以 concatenate 两个字符串:System.out.println(firstName.concat(lastName));
,将 "20"+10,结果是 “2010“,字符串类型;
Math
Math.random()
返回 0(inclusive) to 1 (exclusive) 范围的值,0≤x<1
If...Else
if (condition1) {
// block of code to be executed if condition1 is true
} else if (condition2) {
// block of code to be executed if the condition1 is false and condition2 is true
} else {
// block of code to be executed if the condition1 is false and condition2 is false
}
栗子:
int time = 22;
if (time < 10) {
System.out.println("Good morning.");
} else if (time < 20) {
System.out.println("Good day.");
} else {
System.out.println("Good evening.");
}
三元运算符(Ternary Operator)
variable = (condition) ? expressionTrue : expressionFalse;
栗子:
int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";
Switch
switch(expression) {
case x:
// code block
break;
case y:
// code block
break;
default:
// code block
}
break;
语句要记得写,不然一直往下执行,直到遇到break;
default
语句是用来当没有匹配条件时执行的,它不需要break
While 循环
while (condition) {
// code block to be executed
}
Do/While
循环是上面那种写法的一个变体(variant)。这个循环是在检查条件之前,就会直接执行一次代码!然后判断条件,执行循环。
do {
// code block to be executed
}
while (condition);
For 循环
for (statement 1; statement 2; statement 3) {
// code block to be executed
}
- 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
- 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
- 执行一次循环后,更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程
For-Each 循环
for (type variable 声明语句: arrayname 数组名) {
// code block to be executed
}
栗子:
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
System.out.println(i);
}
Arrays 数组
Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value.
数组用于在单个变量中存储多个值,而不是为每个值声明单独的变量。
栗子:
// 用变量类型+方括号(square brackets)
String[] cars;
// 在大括号内(inside curly braces)放入值
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
数组元素的操作:
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars[0]); // 输出首个元素
cars[0]="Opel"; // 修改首个元素值
System.out.println(cars.length); // 数组的长度,这里不用调用方法
// 数组的循环
for (int i=0;i < cars.length; i++){
System.out.println(cars[i]);
}
// for-each 循环
for (String i : cars){
System.out.println(i);
}
多维数组(Multidimensional Arrays)
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x); // Outputs 7
Exceptions
try {
// Block of code to try
}
catch(Exception e) {
// Block of code to handle errors
}
栗子?:
public class MyClass {
public static void main(String[] args) {
try {
int[] myNumbers = {1, 2, 3};
System.out.println(myNumbers[10]);
} catch (Exception e) {
System.out.println("Something went wrong.");
} finally {
System.out.println("The 'try catch' is finished.");
}
}
}
finally
语句,不论上面结果如何,最终都要执行;
throw
关键字可以让你创建一个自定义的 error
:
public class MyClass {
static void checkAge(int age) {
if (age < 18) {
throw new ArithmeticException("Access denied - You must be at least 18 years old.");
}
else {
System.out.println("Access granted - You are old enough!");
}
}
public static void main(String[] args) {
checkAge(15); // Set age to 15 (which is below 18...)
}
}
Methods 方法
一个方法就是一个代码块,它在被调用时运行。
public class MyClass {
static void myMethod() {
// code to be executed
}
}
myMethod
方法名;void
表示这个方法没有返回值;static
表示这个方法属于MyClass
这个类,不是MyClass
类的对象。
方法参数
public class MyClass {
static void myMethod(String fname) {
System.out.println(fname + " Refsnes");
}
public static void main(String[] args) {
myMethod("Liam");
myMethod("Jenny");
myMethod("Anja");
}
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes
方法返回值
public class MyClass {
static int myMethod(int x, int y) {
return x + y;
}
public static void main(String[] args) {
System.out.println(myMethod(5, 3));
}
}
// Outputs 8 (5 + 3)
Java Classes 类
类和对象 Classes and Objects
Java 是一个 OOP 语言(object-oriented programming),面向对象编程。
对象具有属性(attributes)和方法(methods)。
创建对象:
public class MyClass {
int x = 5; // 这里的 x 就是 MyClass 的 attribute,也叫 fields
public static void main(String[] args) {
MyClass myObj1 = new MyClass(); // Object 1
MyClass myObj2 = new MyClass(); // Object 2
myObj2.x = 25;
System.out.println(myObj1.x); // Outputs 5
System.out.println(myObj2.x); // Outputs 25
}
}
- 发现在当前定义的类中,就已经可以用这个类创建对象了;
- 类名首字母就要大写啦,它是非原始类型的数据类型;
- 类名要和文件名一致;
- 两个类文件在同一级目录下,直接可以调用另一个类创建对象,不像 Python 还需要 import 模块;
- 创建多个对象时,及时一个对象的属性值修改了,不会影响到其他对象的属性值;
final
关键字:
如果你不像类属性在后面被修改,可以使用 final
关键字声明属性
public class MyClass {
final int x = 10;
public static void main(String[] args) {
MyClass myObj = new MyClass();
myObj.x = 25; // will generate an error: cannot assign a value to a final variable
System.out.println(myObj.x);
}
}
- 会报错:
Error:(8, 14) java: 无法为最终变量x分配值
final
关键字在你想要让一个变量总是存储同样的值(也就是值不变)时,很有用;final
被叫做修饰符(modifier);
Methods 方法
public class MyClass {
static void myMethod() {
System.out.println("Hello World!");
}
public static void main(String[] args) {
myMethod(); // 没有创建对象,就可以调用方法,static 的功劳
}
}
Static or Public
static
方法可以不用创建类的对象就可以被调用,不像 public 方法(只能通过创建对象来调用)
栗子?:
public class MyClass {
// Static method
static void myStaticMethod() {
System.out.println("Static methods can be called without creating objects");
}
// Public method
public void myPublicMethod() {
System.out.println("Public methods must be called by creating objects");
}
// Main method
public static void main(String[ ] args) {
myStaticMethod(); // Call the static method
// myPublicMethod(); This would compile an error
MyClass myObj = new MyClass(); // Create an object of MyClass
myObj.myPublicMethod(); // Call the public method on the object
}
}
Constructors 构造器
构造器是 Java 中的特殊方法,用来初始化对象。当通过类创建一个对象的时候,构造器就被调用了。它被用来设置对象属性的初始值。
public class Car {
int modelYear;
String modelName;
public Car(int year, String name) {
modelYear = year;
modelName = name;
}
public static void main(String[] args) {
Car myCar = new Car(1969, "Mustang");
System.out.println(myCar.modelYear + " " + myCar.modelName);
}
}
// Outputs 1969 Mustang
- 构造器的名字必须和类名相同,它不能有返回值(类似 void);
- 所有的类都有构造器。如果你没创建, Java 会自动创建。
修饰符 Modifiers
修饰符分为两种:
- 1.访问修饰符 控制访问等级
- default( 缺省 ) 在同一包内可见,使用对象:类、接口、变量、方法
- public 对所有类可见,使用对象:类、接口、变量、方法
- private 「私有」,在同一类内可见,使用对象:变量、方法。注意:不能修饰类。私有访问修饰符是最严格的访问级别!被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问
- protected 对同一包内的类和所有子类可见。使用对象:变量、方法。注意:不能修饰类。
- 2.非访问修饰符 不控制访问等级,但是提供其他功能
- final 用来修饰类、方法、变量,final 修饰的类不能被继承,修饰的方法不能被继承类重新定义,修饰的变量为「常量」,不可修改。
- static 用来修饰类方法和类变量,类方法、类变量属于类而不是一个对象。对类变量和方法的访问可以直接使用
classname.variablename
和classname.methodname
的方式访问。 - abstract 修饰符,用来创建抽象类和抽象方法,抽象方法没有方法体,抽象方法只能在抽象类中,否则会报错;但是抽象类中定义非抽象方法是不会报错的;
- synchronized 和 volatile 修饰符,主要用于线程的编程;
Encapsulation 封装
为了实现封装:
- 声明属性/变量时,使用
private
修饰符(在同一类内可见); - 提供 public setter 和 getter 方法来获取和修改 private 变量;
栗子:
/* 文件名: EncapTest.java */
public class EncapTest{
private String name;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
}
this
关键字用来指向当前的对象;
Packages 包
Java 的包是用来将相关类分组的,可以把它看做是一个文件夹。
包的作用:
- 把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
- 如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。因此,包可以避免名字冲突。
- 包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
Java 使用包(package)这种机制是为了防止命名冲突,访问控制,提供搜索和定位类(class)、接口、枚举(enumerations)和注释(annotation)等。
Java 包分为两类:
- 内置包(Built-in Packages),来自 Java API 的包;
- 用户自定义的包;
Built-in Packages
// 语法
import package.name.Class; // Import a single class
import package.name.*; // Import the whole package
引入一个类
import java.util.Scanner;
java.util
是一个 package,Scanner
是它的一个类;
引入一个包
import java.util.*;
自定义包
使用 package
关键字:
package mypack;
注意:类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后,类声明之前
继承 Inheritance
- subclass(child) 子类
- superclass(parent) 超类/父类
为了继承某个类,使用 extends
关键字。
class Vehicle {
protected String brand = "Ford"; // Vehicle attribute
public void honk() { // Vehicle method
System.out.println("Tuut, tuut!");
}
}
class Car extends Vehicle {
private String modelName = "Mustang"; // Car attribute
public static void main(String[] args) {
// Create a myCar object
Car myCar = new Car();
// Call the honk() method (from the Vehicle class) on the myCar object
myCar.honk();
// Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class
System.out.println(myCar.brand + " " + myCar.modelName);
}
}
- Vehicle 中使用了一个
protected
修饰符,如果使用了private
修饰符,那么 Car 类是无法获取brand
属性的;
Polymorphism 多态
同一个事件发生在不同的对象上会产生不同的结果。
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象
class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}
class Pig extends Animal {
// 继承自 Animal
// 重写了 animalSoud 方法
public void animalSound() {
System.out.println("The pig says: wee wee");
}
}
class Dog extends Animal {
public void animalSound() {
System.out.println("The dog says: bow wow");
}
}
class MyMainClass {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Create a Animal object
// 父类 指向 子类
// Parent p = new Child();
Animal myPig = new Pig(); // Create a Pig object
Animal myDog = new Dog(); // Create a Dog object
myAnimal.animalSound();
myPig.animalSound();
myDog.animalSound();
}
}
- 重写(override)的规则:
- 参数列表必须完全与被重写方法的相同;
- 返回类型必须完全与被重写方法的返回类型相同;
- 访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected。
- 父类的成员方法只能被它的子类重写。
- 声明为final的方法不能被重写。
- 声明为static的方法不能被重写,但是能够被再次声明
- 子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为private和final的方法
- 构造方法不能被重写。
- 重载(overload):重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载
-
- 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
- 多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理
Interface 接口
一个 Interface
是一个 抽象类,用来将一些 empty
bodies 的方法组织在一起。
// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void run(); // interface method (does not have a body)
}
接口类必须被其他类以关键字 implements
实现,接口方法由「实现」类提供:
// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void sleep(); // interface method (does not have a body)
}
// Pig "implements" the Animal interface
class Pig implements Animal {
public void animalSound() {
// The body of animalSound() is provided here
System.out.println("The pig says: wee wee");
}
public void sleep() {
// The body of sleep() is provided here
System.out.println("Zzz");
}
}
class MyMainClass {
public static void main(String[] args) {
Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep();
}
}
关于接口的注意点:
- 接口类不能用于创建对象;
- 接口方法不能拥有方法体;
- 接口的实现类,必须重写它所有的方法;
- 接口方法默认是
abstract
和public
修饰符; - 接口属性默认是
public
static
和final
- 一个接口不能包含一个构造器(因为它不能用来创建对象)
Java不支持“多重继承”(一个类只能从一个超类继承)。 但是,它可以通过接口实现,因为该类可以实现多个接口。 注意:要实现多个接口,请使用逗号分隔它们(请参阅下面的示例)。
interface FirstInterface {
public void myMethod(); // interface method
}
interface SecondInterface {
public void myOtherMethod(); // interface method
}
// DemoClass "implements" FirstInterface and SecondInterface
class DemoClass implements FirstInterface, SecondInterface {
public void myMethod() {
System.out.println("Some text..");
}
public void myOtherMethod() {
System.out.println("Some other text...");
}
}
class MyMainClass {
public static void main(String[] args) {
DemoClass myObj = new DemoClass();
myObj.myMethod();
myObj.myOtherMethod();
}
}
抽象类和接口的区别:
- 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
- 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是
public static final
类型的。 - 接口中不能含有静态代码块以及静态方法(用
static
修饰的方法),而抽象类是可以有静态代码块和静态方法。 - 一个类只能继承一个抽象类,而一个类却可以实现多个接口。
- 接口不能用于实例化对象。
- 接口没有构造方法。
- 接口中所有的方法必须是抽象方法。
- 接口不能包含成员变量,除了 static 和 final 变量。
- 接口不是被类继承了,而是要被类实现。
- 接口支持多继承。
Enums 枚举类
枚举是一个特殊的“类”,它表示一组常量(不变的变量,如 final
变量)。
enum Level {
LOW, // 常量用逗号隔开,必须用大写字母
MEDIUM,
HIGH
}
Level myVar = Level.MEDIUM; // 获取枚举的常量值
- myVar 类型就是
Level
,不是String
循环:
for (Level myVar : Level.values()) {
System.out.println(myVar);
}
User Input 用户输入
Scanner
类用于获取用户输入,它在 java.util
包中。
nextBoolean()
从用户获取boolean
值nextByte()
从用户获取一个字节的值nextDouble
nextFload
nextInt()
nextLine()
nextLong()
nextShort()
栗子?:
import java.util.Scanner;
class MyClass {
public static void main(String[] args) {
Scanner myObj = new Scanner(System.in);
System.out.println("Enter name, age and salary");
// String input
String name = myObj.nextLine();
// Numerical input
int age = myObj.nextInt();
double salary = myObj.nextDouble();
// Output input by user
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Salary: " + salary);
}
}
Data and Time 日期和时间
Java 没有内置的 Date 类,可以通过引入 java.time
包来使用。这个包包含许多日期和时间类,例如:
Class | 描述 |
---|---|
LocalDate | 表示日期,year,month,day(yyyy-MM-dd) |
LocalTime | 表示时间,hour,minute,second and microsecond(HH-mm-se-zzz) |
LocalDateTime | 表示日期和时间 (yyyy-MM-dd-HH-mm-ss.zzz) |
DateTimeFormatter | 用于显示和解析日期时间对象的Formatter |
Current Date /当前时间 Current Time 显示当前日期
import java.time.LocalDate; // import the LocalDate class 引入 LocalDate 类
import java.time.LocalTime; // import the LocalTime class
public class MyClass {
public static void main(String[] args) {
// 当前日期
LocalDate myObj = LocalDate.now(); // Create a date object 可以看到,这里创建对象没有使用 new 关键字
System.out.println(myObj); // Display the current date
//2018-12-28
// 当前时间
LocalTime myObj = LocalTime.now();
System.out.println(myObj);
// 15:34:46.622
// 可以看到,这里的时间格式并不是很好看
// 显示当前日期和时间
LocalDateTime myDateTime = LocalDateTime.now();
// 2018-12-28T15:36:56.581
// 格式化日期和时间 ★★★
// 1 now 方法创建时间日期对象
LocalDateTime myDateObj = LocalDateTime.now();
System.out.println("Before formatting: " + myDateObj);
// 2 创建格式化器对象
DateTimeFormatter myFormatObj = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
// 3 时间日期对象调用格式化器
String formattedDate = myDateObj.format(myFormatObj);
System.out.println("After formatting: " + formattedDate);
}
}
ofPattern()
方法接受各种值的排序,如果你想要显示一个不同格式的日期时间值,可以这么做:
yyyy-MM-dd
"1988-09-29"dd/MM/yyyy
"29/09/1988"dd-MMM-yyyy
"29-Sep-1988"E, MMM dd yyyy
"Thu, Sep 29 1988"
更多日期格式,可以查看:
ArrayList 数组列表
ArrayList
类一个大小可调整(resizeable) 的数组(array),这个类位于 java.util
包中。
和内置的数组相比,内置数组的大小是不可变的(如果你要增加 or 删除数组的元素,你必须新建一个新的数组),而 ArrayList
可以新增、删除元素。
栗子:
import java.util.ArrayList; // import the ArrayList class
public class MyClass {
public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>(); // Create an ArrayList object
// Add Items
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
System.out.println(cars);
// Access an Item
System.out.println(cars.get(0));
// Change an Item
cars.set(0,"VV5"); // return oldValue
// Remove an Item
cars.remove(0); // return oldValue
cars.clear(); // 删除全部元素
// Size
cars.size(); // get how many elements
for (String i : cars) {
System.out.println(i);
}
// 或者这么写
for(int i = 0; i < cars.size(); i++){
System.out.println(cars.get(i));
}
// java.util 包中还有一个有用的 `Collections` 类,它包含了 sort() 方法,可以字母排序或者数字排序
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);
Collections.sort(myNumbers);
// Sort myNumbers,这在 Python 中属于就地改变的一种排序 in place,因为它直接改变了 myNumbers 这个列表的元素顺序
for (int i : myNumbers) {
System.out.println(i);
}
}
}
add
方法其实还可以指定插入的索引位置,这就是利用了 Java 中「重载」的概念,方法名一样,参数不一样-》表现行为就不一样。
参考:
HashMap
HashMap 使用「键值对」的方式存储元素,感觉就是和 Python 中的字典一个效果。
import java.util.HashMap;
public class MyClass {
public static void main(String[] args) {
// 创建了一个 HashMap 对象,它存储 String 类型的 键,存储 String 类型的值
// Create a HashMap object called capitalCities
HashMap<String, String> capitalCities = new HashMap<String, String>();
// Add keys and values (Country, City)
capitalCities.put("England", "London");
capitalCities.put("Germany", "Berlin");
capitalCities.put("Norway", "Oslo");
capitalCities.put("USA", "Washington DC");
System.out.println(capitalCities);
// Access an Item
capitalCities.get("England");
//Remove an Item
capitalCities.remove("England");
//Remove all
capitalCities.clear();
//HashMap Size
capitalCities.size();
//循环,keySet() 只返回 keys
//values() 只返回 values
// Print keys and values
for (String i : capitalCities.keySet()) {
System.out.println("key: " + i + " value: " + capitalCities.get(i));
}
}
}
Files 文件
使用 File
类创建一个对象,指定文件名或者目录名:
import java.io.File;
public class GetFileInfo {
public static void main(String[] args) {
File myObj = new File("filename.txt");
// Get file info
if (myObj.exists()) {
System.out.println("File name: " + myObj.getName());
System.out.println("Absolute path: " + myObj.getAbsolutePath());
System.out.println("Writeable: " + myObj.canWrite());
System.out.println("Readable " + myObj.canRead());
System.out.println("File size in bytes " + myObj.length());
} else {
System.out.println("The file does not exist.");
}
}
}
输出:
File name: filename.txt
Absolute path: C:\Users\MyName\filename.txt
Writeable: true
Readable: true
File size in bytes: 0
import java.io.FileWriter; // Import the FileWriter class
import java.io.IOException; // Import the IOException class to handle errors
public class WriteToFile {
public static void main(String[] args) {
try {
FileWriter myWriter = new FileWriter("filename.txt");
myWriter.write("Files in Java might be tricky, but it is fun enough!");
myWriter.close(); //当写好文件之后,需要关闭
System.out.println("Successfully wrote to the file.");
} catch (IOException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}
}
}
输出:
Successfully wrote to the file.
常用方法
System.out.println("Hello World");
打印信息
FAQ
Java中如何理解父类的引用指向类的对象?
- 知乎-Java中如何理解父类的引用指向类的对象。。初学者。。? 介绍的很棒,多态的妙处!
教程
- w3schools-Java Tutorial 虽然是英文版,但还是比较通俗易懂的,推荐;