JavaSE 完结,撒花🌸🌸🌸,Java-基础的学习就将告一段落,今天我将之前发布的《Java-XXX》系列学习笔记进行汇总一下,此系列是我做的一个 “Java 从 0 到 1” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!<有同样想法的小伙伴,可以联系我一起交流学习哦!>
JDK 推荐使用 Zulu JDK,因为适配了 ARM 架构,下载 Download Azul Zulu Builds of OpenJDK
根据需求选择 .dmg 格式的 JDK 下载就可以了,下载后点击安装,按照步骤进行,完成后,在控制台输入java -version
查看是否安装成功
$ java -version
openjdk version "1.8.0_312"
OpenJDK Runtime Environment (Zulu 8.58.0.13-CA-macos-aarch64) (build 1.8.0_312-b07)
OpenJDK 64-Bit Server VM (Zulu 8.58.0.13-CA-macos-aarch64) (build 25.312-b07, mixed mode)
Zulu JDK
默认安装在/Library/Java/JavaVirtualMachines
目录下
/usr/libexec/java_home -V #查看安装Java路径
我安装了一个Zulu的JDK8 和一个HotSpot 的JDK8,所以进行如下配置
# Java config
## Zulu
export JAVA_Z8_HOME="/Library/Java/JavaVirtualMachines/zulu-8.jdk/Contents/Home"
## HotSpot
export JAVA_H8_HOME="/Library/Java/JavaVirtualMachines/jdk1.8.0_351.jdk/Contents/Home"
# config alias
alias jdkz8="export JAVA_HOME=$JAVA_Z8_HOME"
alias jdkh8="export JAVA_HOME=$JAVA_H8_HOME"
# config default jdk
export JAVA_HOME=$JAVA_Z8_HOME
export PATH="$JAVA_HOME:$PATH"
source ~/.zshrc
JDK版本切换
$ jdkz8
$ java -version
openjdk version "1.8.0_312"
OpenJDK Runtime Environment (Zulu 8.58.0.13-CA-macos-aarch64) (build 1.8.0_312-b07)
OpenJDK 64-Bit Server VM (Zulu 8.58.0.13-CA-macos-aarch64) (build 25.312-b07, mixed mode)
$ jdkh8
$ java -version
java version "1.8.0_351"
Java(TM) SE Runtime Environment (build 1.8.0_351-b10)
Java HotSpot(TM) 64-Bit Server VM (build 25.351-b10, mixed mode)
首先创建一个季节(Season) 对象
package com.jwt.enum_;
public class Enumeration01 {
public static void main(String[] args) {
//使用
Season spring = new Season("春天", "温暖");
Season winter = new Season("冬天", "寒冷");
Season summer = new Season("夏天", "炎热");
Season autumn = new Season("秋天", "凉爽");
autumn.setName("XXX");//可以修改秋天的名字
autumn.setDesc("非常的热..");//可以修改秋天的描述
Season other = new Season("红天", "~~~");//可以增加其他季节
System.out.println(autumn);
}
}
class Season {
private String name;
private String desc;//描述
public Season(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
Season 对象要有如下特点
上面代码的方法不满足上面的两个特点,要如何实现呢?答:使用枚举
枚举有二种实现方式:1.自定义类实现、2.使用 enum 关键字实现
package com.jwt.enum_;
public class Enumeration02 {
public static void main(String[] args) {
System.out.println(Season.AUTUMN);
System.out.println(Season2.SUMMER);
}
}
class Season {
private String name;
private String desc;//描述
//定义了四个对象, 固定.
public static final Season SPRING = new Season("春天", "温暖");
public static final Season WINTER = new Season("冬天", "寒冷");
public static final Season AUTUMN = new Season("秋天", "凉爽");
public static final Season SUMMER = new Season("夏天", "炎热");
//1. 将构造器私有化,目的防止直接new
//2. 去掉setXxx 方法, 防止属性被修改
//3. 在Season 内部,直接创建固定的对象
//4. 优化,可以加入final 修饰符
private Season(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
package com.jwt.enum_;
public class Enumeration03 {
public static void main(String[] args) {
System.out.println(Season2.AUTUMN);
System.out.println(Season2.SUMMER);
}
}
enum Season2 {
SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
SUMMER("夏天", "炎热")/*, What()*/;
private String name;
private String desc;//描述
private Season2() {//无参构造器
}
private Season2(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
注意事项
1.当我们使用 enum 关键字开发一个枚举类时,默认会继承 Enum 类, 而且是一个 final 类,使用javap 工具可以看到
2.传统的public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成SPRING(“春天”, “温暖”), 这里必须知道,它调用的是哪个构造器
3.如果使用无参构造器创建枚举对象,则实参列表和小括号都可以省略
4.当有多个枚举对象时,使用 “,” 间隔,最后有一个分号结尾
5.枚举对象必须放在枚举类的行首
Javap 反编译上面生成的 class,可以分析出跟自定义实现方法差不多
$ javac Enumeration03.java
$ javap Season2.class
Compiled from "Enumeration03.java"
final class com.jwt.enum_.Season2 extends java.lang.Enum<com.jwt.enum_.Season2> {
public static final com.jwt.enum_.Season2 SPRING;
public static final com.jwt.enum_.Season2 WINTER;
public static final com.jwt.enum_.Season2 AUTUMN;
public static final com.jwt.enum_.Season2 SUMMER;
public static com.jwt.enum_.Season2[] values();
public static com.jwt.enum_.Season2 valueOf(java.lang.String);
public java.lang.String getName();
public java.lang.String getDesc();
public java.lang.String toString();
static {};
}
使用关键字enum 时,会隐式继承Enum 类, 这样我们就可以使用Enum 类相关的方法。
package com.jwt.enum_;
public class EnumMethod {
public static void main(String[] args) {
//使用Season2 枚举类,来演示各种方法
Season2 autumn = Season2.AUTUMN;
//输出枚举对象的名字
System.out.println(autumn.name());
//ordinal() 输出的是该枚举对象的次序/编号,从0 开始编号
//AUTUMN 枚举对象是第三个,因此输出2
System.out.println(autumn.ordinal());
//从反编译可以看出values 方法,返回Season2[]
//含有定义的所有枚举对象
Season2[] values = Season2.values();
System.out.println("===遍历取出枚举对象(增强for)====");
for (Season2 season : values) {//增强for 循环
System.out.println(season);
}
//valueOf:将字符串转换成枚举对象,要求字符串必须为已有的常量名,否则报异常
//1. 根据你输入的"AUTUMN" 到Season2 的枚举对象去查找
//2. 如果找到了,就返回,如果没有找到,就报错
Season2 autumn1 = Season2.valueOf("AUTUMN");
System.out.println("autumn1=" + autumn1);
//compareTo:比较两个枚举常量,比较的就是编号
//1. 就是把Season2.AUTUMN 枚举对象的编号和Season2.SUMMER 枚举对象的编号比较
/*源码
public final int compareTo(E o) {
return self.ordinal - other.ordinal;
}
*/
//Season2.AUTUMN 的编号[2] - Season2.SUMMER 的编号[3]
System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
}
}
package com.jwt.enum_;
public class EnumExercise02 {
public static void main(String[] args) {
//获取到所有的枚举对象, 即数组
Week[] weeks = Week.values();
//遍历,使用增强for
for (Week w:weeks) {
System.out.println(w);
}
}
}
enum Week{
MONDAY("星期一"),TUESDAY("星期二"), WEDNESDAY("星期三"),
THURSDAY("星期四"), FRIDAY("星期五"),SATURDAY("星期六"), SUNDAY("星期天");
private String name;
Week(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Week{" +
"name='" + name + '\'' +
'}';
}
}
使用 enum 关键字后,就不能再继承其它类了,因为 enum 会隐式继承 Enum,而Java 是单继承机制。
枚举类和普通类一样,可以实现接口
enum 类名 implements 接口1,接口2{}
package com.jwt.enum_;
/**
* @author:简简
* @createTime:[2022/3/13 13:20]
**/
public class EnumDetail {
public static void main(String[] args) {
Music.CLASSICMUSIC.playing();
}
}
class A {
}
interface Playing {
public void playing();
}
enum Music implements Playing {
CLASSICMUSIC;//无参构造器,创建常量对象,则可以省略()
@Override
public void playing() {
System.out.println("播放好听的音乐...");
}
}
三个基本的 Annotation
@Override: 限定某个方法,是重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示某个程序元素(类, 方法等)已过时,该注解可以修饰方法,类,字段, 包, 参数等等
@SuppressWarnings(“all”): 抑制编译器警告
可以指定的警告类型有
all,抑制所有警告
boxing,抑制与封装/拆装作业相关的警告
cast,抑制与强制转型作业相关的警告
dep-ann,抑制与淘汰注释相关的警告
deprecation,抑制与淘汰的相关警告
fallthrough,抑制与switch 陈述式中遗漏break 相关的警告
finally,抑制与未传回finally 区块相关的警告
hiding,抑制与隐藏变数的区域变数相关的警告
incomplete-switch,抑制与switch 陈述式(enum case)中遗漏项目相关的警告
javadoc,抑制与javadoc 相关的警告第497页
nls,抑制与非nls 字串文字相关的警告
null,抑制与空值分析相关的警告
rawtypes,抑制与使用raw 类型相关的警告
resource,抑制与使用Closeable 类型的资源相关的警告
restriction,抑制与使用不建议或禁止参照相关的警告
serial,抑制与可序列化的类别遗漏serialVersionUID 栏位相关的警告
static-access,抑制与静态存取不正确相关的警告
static-method,抑制与可能宣告为static 的方法相关的警告
super,抑制与置换方法相关但不含super 呼叫的警告
synthetic-access,抑制与内部类别的存取未最佳化相关的警告
sync-override,抑制因为置换同步方法而遗漏同步化的警告
unchecked,抑制与未检查的作业相关的警告
unqualified-field-access,抑制与栏位存取不合格相关的警告
unused,抑制与未用的程式码及停用的程式码相关的警告
元注解的基本介绍
- Retention //指定注解的作用范围,三种SOURCE,CLASS,RUNTIME
- RetentionPolicy.SOURCE: 编译器使用后,直接丢弃这种策略的注释
- RetentionPolicy.CLASS: 编译器将把注解记录在 class 文件中,当运行 Java 程序时, JVM 不会保留注解。这是默认值
- RetentionPolicy.RUNTIME:编译器将把注解记录在 class 文件中,当运行 Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注解
- Target // 指定注解可以在哪些地方使用
- Documented //指定该注解是否会在javadoc 体现
- Inherited //子类会继承父类注解
Java语言中,将程序执行中发生的不正常情况称为”异常”。(开发过程中的语法错误和逻辑错误不是异常)
执行过程中所发生的异常事件可分为两大类
当应用程序试图在需要对象的地方使用null 时,抛出该异常
public class NullPointerException_ {
public static void main(String[] args) {
String name = null;
System.out.println(name.length());
}
}
当出现异常的运算条件时,抛出此异常。
public class ArithmeticException_ {
public static void main(String[] args) {
int num1 = 10;
int num2 = 0;
int res = num1 / num2;
}
}
用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引
public class ArrayIndexOutOfBoundsException_ {
public static void main(String[] args) {
int[] arr = {1, 2, 4};
for (int i = 0; i <= arr.length; i++) {
System.out.println(arr[i]);
}
}
}
当试图将对象强制转换为不是实例的子类时,抛出该异常
public class ClassCastException_ {
public static void main(String[] args) {
A b = new B(); //向上转型
B b2 = (B)b;//向下转型,这里是OK
C c2 = (C)b;//这里抛出ClassCastException
}
}
class A {}
class B extends A {}
class C extends A {}
当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常
public class NumberFormatException_ {
public static void main(String[] args) {
String name = "教育";
//将String 转成int
int num = Integer.parseInt(name);//抛出NumberFormatException
System.out.println(num);
}
}
异常处理就是当异常发生时,对异常处理的方式。
Java提供try和catch块来处理异常。 try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有多个try..catch块。
public class TryCatchDetail {
public static void main(String[] args) {
try {
String str = "测试";
int a = Integer.parseInt(str);
System.out.println("数字:" + a);
} catch (NumberFormatException e) {
System.out.println("异常信息:" + e.getMessage());
} finally {
System.out.println("finally 代码块被执行...");
}
System.out.println("程序继续...");
}
}
public class TryCatchDetail02 {
public static void main(String[] args) {
//1.如果try 代码块有可能有多个异常
//2.可以使用多个catch 分别捕获不同的异常,相应处理
//3.要求子类异常写在前面,父类异常写在后面
try {
Person person = new Person();
person = null;
System.out.println(person.getName());//NullPointerException
} catch (NullPointerException e) {
System.out.println("空指针异常:" + e.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
class Person {
private String name = "jack";
public String getName() {
return name;
}
}
public class TryCatchDetail03 {
public static void main(String[] args) {
try{
int n1 = 10;
int n2 = 0;
System.out.println(n1 / n2);
}finally {
System.out.println("执行了finally..");
}
System.out.println("程序继续执行..");
}
}
请编写程序,在 ArrayList 中,添加 3 个 Dog 对象,Dog 对象含有 name 和 age,并输出 name 和age (要求使用getXxx())
package com.jwt.generic;
import java.util.ArrayList;
public class Generic01 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(new Dog("小黄",10));
arrayList.add(new Dog("小白",2));
arrayList.add(new Dog("小黑",5));
for (Object o : arrayList){
Dog dog = (Dog) o;//需要向下转型Object ->Dog
System.out.println(dog.getName());
}
}
}
class Dog {
private String name;
private int age;
public Dog() {
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.jwt.generic;
import java.util.ArrayList;
public class Generic02 {
public static void main(String[] args) {
ArrayList<Dog> arrayList = new ArrayList<>();
arrayList.add(new Dog("小黄",10));
arrayList.add(new Dog("小白",2));
arrayList.add(new Dog("小黑",5));
for (Dog dog : arrayList){
System.out.println(dog.getName());
}
}
}
class Dog {
private String name;
private int age;
public Dog() {
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
泛型有三种常用的使用方式:泛型类,泛型接口和泛型方法。
class Person<E>{//如果创建对象时没有指定类型,默认是 Object
E s;
public Person(E s) {
this.s = s;
}
}
泛型类型必须是引用类型(非基本数据类型)
List<Integer> list = new ArrayList<Integer>(); //正确
List<int> list2 = new ArrayList<int>();//错误
泛型的使用形式
List<Integer> list = new List<Integer>();
List<Integer> list = new List<>();//推荐使用简写
静态方法和静态属性不能使用泛型
泛型默认是Object
List List = new List();
//等价
List<Object> List = new List<>();
由于使用自定义泛型的类,只有在实例化的时候才知道这个类型参数是什么,所以导致
public interface Test_ <E>{
//...
}
泛型接口的类型,在继承接口 或者 实现接口时确定。(默认Object)
例子
/**
* 泛型接口的定义格式: 修饰符 interface 接口名<数据类型> {}
*/
public interface Inter<T> {
public abstract void show(T t) ;
}
/**
* 子类是泛型类
*/
public class InterImpl<E> implements Inter<E> {
@Override
public void show(E t) {
System.out.println(t);
}
}
Inter<String> inter = new InterImpl<String>() ;
inter.show("hello") ;
public <E> void Come(E e){
//...
}
泛型方法,可以使用类声明的泛型,也可以使用自己声明泛型
class Fish<T, R> {//泛型类
public void run() {//普通方法
}
public<U,M> void eat(U u, M m) {//泛型方法
}
//说明
//1. 下面hi 方法不是泛型方法
//2. 是hi 方法使用了类声明的泛型
public void hi(T t) {
}
//泛型方法,可以使用类声明的泛型,也可以使用自己声明泛型
public<K> void hello(R r, K k) {
System.out.println(r.getClass());//ArrayList
System.out.println(k.getClass());//Float
}
}
例子
class Demo{
public <T> T fun(T t){ // 可以接收任意类型的数据
return t ; // 直接把参数返回
}
};
public class GenericsDemo{
public static void main(String args[]){
Demo d = new Demo() ; // 实例化Demo对象
String str = d.fun("汤姆") ; // 传递字符串
int i = d.fun(30) ; // 传递数字,自动装箱
System.out.println(str) ; // 输出内容
System.out.println(i) ; // 输出内容
}
};
下面是List接口和ArrayList类的代码片段
//定义接口时指定了一个类型形参,该形参名为E
public interface List<E> extends Collection<E> {
//在该接口里,E可以作为类型使用
public E get(int index) {}
public void add(E e) {}
}
//定义类时指定了一个类型形参,该形参名为E
public class ArrayList<E> extends AbstractList<E> implements List<E> {
//在该类里,E可以作为类型使用
public void set(E e) {
.......................
}
}
- 该类包含: private成员变量name,sal,birthday, 其中birthday为MyDate类的对象;
- 为每一个属性定义getter, setter方法;
- 重写toString方法输出name, sal, birthday定义MyDate类
- 包含: private成员变量month,day,year;
- 并为每一个属性定义getter,setter方法;创建该类的3个对象,并把这些对象放入ArrayList集合中(ArrayList需使用泛型来定义)
- 对集合中的元素进行排序,并遍历输出
- 排序方式:调用ArrayList 的sort方法,传入Comparator对象[使用泛型],先按照name排序,如果name相同,则按生日日期的先后排序。 即:定制排序
Employee.java
package com.jwt.generic;
public class Employee {
private String name;
private double sal;
private MyDate birthday;
public Employee(String name, double sal, MyDate birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "\nEmployee{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
}
MyDate.java
package com.jwt.generic;
class MyDate implements Comparable<MyDate> {
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
@Override
public int compareTo(MyDate o) {
int yearMinus = year - o.getYear();
if (yearMinus != 0) {
return yearMinus;
}
//如果year相同,比较month
int monthMinus = month - o.getMonth();
if (monthMinus != 0) {
return monthMinus;
}
//如果year和month相同
return day - o.getDay();
}
}
Main.java
package com.jwt.generic;
import java.util.ArrayList;
import java.util.Comparator;
public class GenericExercise02
{
public static void main(String[] args) {
ArrayList<Employee> employees = new ArrayList<>();
employees.add(new Employee("小明",10000, new MyDate(2000,7,2)));
employees.add(new Employee("小红",20000, new MyDate(2002,10,2)));
employees.add(new Employee("小明",30000, new MyDate(2000,6,2)));
System.out.println("employees=" + employees);
employees.sort(new Comparator<Employee>() {
@Override
public int compare(Employee emp1, Employee emp2) {
//先按照name排序,如果name相同,则按生日日期的先后排序。【即:定制排序】
//先对传入的参数进行验证
if (!(emp1 instanceof Employee && emp2 instanceof Employee)) {
System.out.println("类型不正确..");
return 0;
}
//比较name
int i = emp1.getName().compareTo(emp2.getName());
if (i != 0) {
return i;
}
//封装后,将来可维护性和复用性,就大大增强.
return emp1.getBirthday().compareTo(emp2.getBirthday());
}
});
System.out.println("==对雇员进行排序==");
System.out.println(employees);
}
}
泛型不具备继承性
//Object是String的父类
Object o = new String("xx");//正确
List<Object> list = new ArrayList <String>; //错误
通配符
<?>
:支持任意泛型类型<? extends A>
:支持A类以及A类的子类,规定了泛型的上限<? super A>
:支持A类以及A类的父类,不限于直接父类,规定了泛型的下限package com.jwt.generic;
import java.util.ArrayList;
import java.util.List;
public class GenericExtends {
public static void main(String[] args) {
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<AA> list3 = new ArrayList<>();
List<BB> list4 = new ArrayList<>();
List<CC> list5 = new ArrayList<>();
//如果是List<?> c ,可以接受任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//List<? extends AA> c: 表示上限,可以接受AA 或者AA 子类
printCollection2(list1);//×
printCollection2(list2);//×
printCollection2(list3);//√
printCollection2(list4);//√
printCollection2(list5);//√
//List<? super AA> c: 支持AA 类以及AA 类的父类,不限于直接父类
printCollection3(list1);//√
printCollection3(list2);//×
printCollection3(list3);//√
printCollection3(list4);//×
printCollection3(list5);//×
}
//说明: List<?> 表示任意的泛型类型都可以接受
public static void printCollection1(List<?> c) {
for (Object object : c) { // 通配符,取出时,就是Object
System.out.println(object);
}
}
// ? extends ,可以接受AA 或者AA 子类
public static void printCollection2(List<? extends AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
// ? super,支持AA 类以及AA 类的父类,不限于直接父类,
public static void printCollection3(List<? super AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
}
class AA {
}
class BB extends AA {
}
class CC extends BB {
}
。。。
JUnit是一个Java语言的单元测试框架,多数Java的开发环境都已经集成了JUnit作为单元测试的工具
package com.jwt.generic;
public class JUnit_ {
public static void main(String[] args) {
//传统方式
new JUnit_().m1();
new JUnit_().m2();
}
public void m1 () {
System.out.println("m1 方法被调用");
}
public void m2 () {
System.out.println("m2 方法被调用");
}
}
package com.jwt.generic;
public class JUnit_ {
@Test
public void m1 () {
System.out.println("m1 方法被调用");
}
@Test
public void m2 () {
System.out.println("m2 方法被调用");
}
}
Mac:Ctrl + enter
Win:AIt + Inster
首先进入设置选项–>编辑器–>常规–>自动导包–>勾选对应项
使用if..else, try..catch, for, synchronized等包围选中的代码
Win:Ctrl + Alt + t
Mac:option + command + t
Win:Alt + enter
Mac:option + enter
Shift + command + enter
Win:Ctrl + j
Mac:Command + j
快速生成打印:sout
快速生成打印当前值:soutv
快速生成增强for:I
快速生成main方法:main
快速生成迭代器while:输入 itit
Win:AIt+鼠标左键不放,拖动即可
Mac:option+鼠标左键不放,拖动即可
Win:Ctrl+Shift+t
Mac:Command+o
Win:Ctrl+F12
Mac:Command+F12
Win:Ctrl+Shift+↑/↓
Mac:Command+Shift+↑/↓
Win:Ctrl+p
Mac:Command+p
Win:Ctrl+Shift+u
Mac:Command+Shift+u
Win:Ctrl+Alt+m
Mac:Command+option+m
Win:Ctrl+Alt+→/←
Mac:Command+option+→/←
Win:Shift+F6
Mac:Shift+F6