251-270作业/面向对象中级开始/IDEA的使用/IDEA的快捷键
一、本章作业
以下为我的代码
。。。
1、编写一个类A01，定义方法max，实现求某个double数组的最大值，并返回。
Homework01.java
public class Homework01 {
public static void main(String[] args) {
A01 a01 = new A01();
double[] arr = {352.3, 55.2, 1522.1, 33, 55.25};
double res = a01.max(arr);
System.out.println("res = " + res);
}
}
//编写一个类A01
class A01 {
// 方法名称max
// 返回值double
// 功能：double数组最大值
// 参数：double[] 数组
public double max(double[] d) {
double mx = d[0];
for (int i = 1; i < d.length; i++) {
if (d[i] > mx) {
mx = d[i];
}
}
return mx;
}
}
2、编写类A02，定义方法find，实现查找某字符串数组中的元素查找，并返回索引，如果找不到返回-1，Homework02.java
public class Homework02 {
public static void main(String[] args) {
String[] str = {"python", "java", "C++", "go", "C"};
String findElement = "java";
A02 a02 = new A02();
int res = a02.find(str, findElement);
System.out.println("res = " + res);
}
}
// 编写类A02
class A02 {
// 定义方法find
// 接收一个字符串数组和待查找的元素
// 功能：元素查找
// 返回索引int，否则返回-1
public int find(String[] str, String findElement) {
int index = -1; // 找不到返回-1
for (int i = 0; i < str.length; i++) {
if (findElement.equals(str[i])) {
index = i;
}
}
return index;
}
}
3、编写类Book，定义方法updatePrice，实现更改某本书的价格，具体：如果价格 > 150，则更改为150，如果价格 > 100，更改为100，否则不变。
Homework03.java
import java.util.Scanner;
public class Homework03 {
public static void main(String[] args) {
Book book = new Book();
System.out.println("修改之前的价格price = " + book.price);
Scanner scanner = new Scanner(System.in);
char breakQ = ' ';
while (breakQ != 'q') {
System.out.print("请输入修改的价格：");
book.updatePrice(scanner.nextInt());
System.out.println("修改之后的价格price = " + book.price);
System.out.print("如果想要退出输入q，否则输入任意字符回车：");
breakQ = scanner.next().charAt(0);
}
}
}
// 编写Book类
class Book {
int price; // 属性有默认值，局部变量没有默认值，默认值为0
// 定义方法updatePrice
// 功能：更改某本书的价格
// if price > 150 price = 150
// if price > 100 price = 100
// else price
// 返回值：void
// 参数：接收修改的价格
public void updatePrice(int price) {
if (price > 0) {
if (price > 150) {
this.price = 150;
} else if (price > 100) {
this.price = 100;
} else {
this.price = price;
}
} else {
System.out.println("书本的价格需要大于0！");
}
}
}
4、编写类A03，实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样。
Homework04.java
public class Homework04 {
public static void main(String[] args) {
A03 a03 = new A03();
int[] oldArr = new int[10];
for (int i = 0; i < oldArr.length; i++) {
oldArr[i] = (int)(Math.random() * 100 + 1);
}
System.out.println("旧的数组：" + java.util.Arrays.toString(oldArr));
int[] newArr = a03.copyArr(oldArr);
System.out.println("新的数组：" + java.util.Arrays.toString(newArr));
}
}
// 编写类A03
class A03 {
// 方法名称copyArr
// 功能：实现数组的复制功能，元素和旧数组一样
// 参数：旧数组int[] old
// 返回值：新数组int[] new
public int[] copyArr(int[] oldArr) {
int arrLen = oldArr.length;
int[] newArr = new int[arrLen];
for (int i = 0; i < arrLen; i++) {
newArr[i] = oldArr[i];
}
return newArr;
}
}
5、定义一个圆类Circle，定义属性：半径，提供显示圆周长功能的方法，提供显示圆面积的方法。
Homework05.java
public class Homework05 {
public static void main(String[] args) {
Circle circle = new Circle();
circle.r = 4;
System.out.println("r = " + circle.r + "的圆的周长 = " + circle.showCircumference());
System.out.println("r = " + circle.r + "的圆的面积 = " + circle.showArea());
}
}
// 定义一个圆类Circle
class Circle {
// 定义属性
double r;
// 提供显示圆周长功能的方法
// 显示圆面积的方法
public double showCircumference() {
return Math.PI * 2 * this.r;
}
public double showArea() {
return Math.PI * r * r;
}
}
6、编程创建一个Cale计算类，在其中定义两个变量表示两个操作数，定义四个方法实现求和，差，乘，商（要求除数为0的话，要提示）并且创建两个对象，分别测试。
Homework06.java
public class Homework06{
public static void main(String[] args){
Cale cale1 = new Cale();
cale1.n1 = 10;
cale1.n2 = 20;
System.out.println("cale1.add() = " + cale1.add());
System.out.println("cale1.sub() = " + cale1.sub());
System.out.println("cale1.mult() = " + cale1.mult());
System.out.println("cale1.div() = " + cale1.div());
Cale cale2 = new Cale();
cale2.n1 = 10;
cale2.n2 = 0;
System.out.println("cale2.add() = " + cale2.add());
System.out.println("cale2.sub() = " + cale2.sub());
System.out.println("cale2.mult() = " + cale2.mult());
if (cale2.div() == -1) {
System.out.println("分母不能为0");
} else {
System.out.println("cale2.div() = " + cale2.div());
}
}
}
// 创建一个Cale计算类
class Cale {
double n1;
double n2;
public double add() {
return this.n1 + this.n2;
}
public double sub() {
return this.n1 - this.n2;
}
public double mult() {
return this.n1 * this.n2;
}
public double div() {
return this.n2==0 ? -1 : this.n1/this.n2;
}
}
7、设计一个Dog类，有名字、颜色和年龄属性，定义输出方法show，显示其信息。并创建对象，进行测试，提示使用this.属性.
public class Homework07 {
public static void main(String[] args) {
Dog dog = new Dog("小白", "白色", (byte)3);
dog.show();
}
}
class Dog {
String name;
String color;
byte age;
Dog(String name, String color, byte age) {
this.name = name;
this.color = color;
this.age = age;
}
Dog(){}
public void show() {
System.out.println("小狗信息如下：");
System.out.println("name = " + this.name);
System.out.println("color = " + this.color);
System.out.println("age = " + this.age);
}
}
8、给定一个Java程序的代码如下所示，则编译运行之后，输出结果是什么？
public class Test{
int count = 9;
public void count1() {
count = 10;
System.out.println("count1=" + count);
}
public void count2() {
System.out.println("count2 = " + count++);
}
public static void main(String args[]) {
new Test().count1();
Test t1 = new Test();
t1.count1();
t1.count2();
}
}
out:
count1 = 10
count1 = 10
count2 = 10
9、定义Music类，里面有音乐名name、音乐时长times属性，并有播放play功能和返回本身属性信息的功能方法getInfo.
Homework09.java
public class Homework09 {
public static void main(String[] args) {
Music music = new Music("昊天鼓", 8.13);
music.play();
music.getInfo();
}
}
// 定义Music类
class Music {
String name;
double times;
Music(String name, double times) {
this.name = name;
this.times = times;
}
Music(){}
public void play() {
System.out.println("正在播放--" + this.name);
}
public void getInfo() {
System.out.println("歌曲信息如下：");
System.out.println("歌曲名称->" + this.name);
System.out.println("歌曲时长->" + this.times + "分钟");
}
}
10、
试试写出以下代码的运行结果
class Demo {
int i = 100;
public void m() {
int j = i++;
System.out.println("i="+i);
System.out.println("j="+j);
}
}
class Test {
public static void main(String[] args) {
Demo d1 = new Demo();
Demo d2 = d1;
d2.m(); // 101 100
System.out.println(d1.i); // 101
System.out.println(d2.i); // 101
}
}
out：
i=101
j=100
101
101
11、在测试方法中，调用method方法，代码如下，编译正确，试写出method方法的定义形式，调用语句为：
System.out.println(method(method(10.0,20.0),100));
public double method(double n1, double n2){//...
}
12、创建一个Employee类，属性有（名字，性别，年龄，职位，薪水），提供三个构造方法，可以初始化
1、名字，性别，年龄，职位，薪水
2、名字，性别，年龄
3、职位，薪水
要求充分复用构造器
Homework12.java
public class Homework12 {
public static void main(String[] args) {
Employee employee = new Employee();
Employee employee1 = new Employee("python程序员", 10000.88);
Employee employee2 = new Employee("alice", '女', 18);
Employee employee3 = new Employee("alice", '女', 18, "Java程序员", 1000000.888);
}
}
// 创建一个Employee类
class Employee {
// 属性有：名字，性别，年龄，职位，薪水
String name;
char gender;
int age;
String job;
double salary;
// 提供三个构造方法
Employee(String name, char gender, int age, String job, double salary) {
this(name, gender, age);
this.job = job;
this.salary = salary;
} // 名字 性别 年龄 职位 薪水
Employee(String name, char gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
Employee(String job, double salary) {
this.job = job;
this.salary = salary;
}
Employee() {}
}
public class Homework13 {
public static void main(String[] args) {
// Homework13.java
PassObject passobject = new PassObject();
passobject.printAreas(new Circle(), 5);
}
}
/*
将对象作为参数传递给方法。
题目要求：
1、定义一个Circle类，包含一个double类型的radius属性代表圆的半径，findArea()方法返回圆的面积
2、定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
public void printAreas(Circle c, int times) // 方法签名
3、在printAreas方法中打印输出1到times之间的每个整数半径值，以及对应的面积。例如，
times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
4、在main方法中调用printAreas()方法，调用完毕之后输出当前半径值。
*/
// 定义一个Circle类
class Circle {
// double类型的radius属性表示圆的半径
double radius;
// findArea方法
// 功能：返回圆的面积
// 返回值：double
// 参数：无
public double findArea() {
return Math.PI * radius * radius;
}
}
// 定义一个类PassObject
class PassObject {
// 方法printAreas()
public void printAreas(Circle c, int times) {
System.out.println("Radius\t\tArea");
for (int i = 1; i <= times; i++) {
c.radius = i;
System.out.println(c.radius + "\t\t" + c.findArea());
}
}
}
14、扩展题
Homework14.java
import java.util.Scanner;
public class Homework14 {
public static void main(String[] args) {
// Homework14.java
Person person = new Person("Tom");
Host host = new Host();
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("轮到你：");
person.setGuess(scanner.nextInt());
host.setGuess();
System.out.println(host.name + "出->" + host.getGuess());
if ((person.getGuess()==0 && host.getGuess()==1) ||
(person.getGuess()==1 && host.getGuess()==2) ||
(person.getGuess()==2 && host.getGuess()==0)) {
System.out.println("你赢了！");
person.win++;
} else if ((person.getGuess()==0 && host.getGuess()==2) ||
(person.getGuess()==1 && host.getGuess()==0) ||
(person.getGuess()==2 && host.getGuess()==1) ) {
System.out.println("你输了！");
person.lose++;
} else {
System.out.println("平局！");
}
System.out.println("--------清单--------");
System.out.println("win\t\tlose");
System.out.println(person.win + "\t\t" + person.lose);
System.out.print("如果要退出可以输入q然后回车，否则输入任意字符回车继续：");
if (scanner.next().charAt(0) == 'q') {
System.out.println("游戏结束...");
break;
}
}
}
}
/*
有个人Tom设计他的成员变量，成员方法可以电脑猜拳，
电脑每次都会随机生成0，1，2
0表示石头
1表示剪刀
2表示布
并要显示Tom的输赢次数（清单）
**/
class Person {
int guess;
String name;
int win;
int lose;
Person(String name) {
this.name = name;
}
public void setGuess(int guess) {
this.guess = guess;
}
public int getGuess() {
return this.guess;
}
}
class Host {
int guess;
String name = "电脑";
public void setGuess() {
this.guess = (int)(Math.random() * 3); // Math.random() -> [0.0, 1.0) -> [0, 3) -> 0,1,2
}
public int getGuess() {
return this.guess;
}
}
tip：
先简单这样写，等到后期回来优化和做图形化的。
以下为老师的代码
。。。
1、编写类A01，定义方法max，实现求某个double数组的最大值，并返回
思路分析：
1、类名A01
2、方法名max
3、形参（double[])
4、返回值 double
先完成正常业务，然后再考虑代码健壮性
class A01 {
public double max(double[] arr) {
double max = arr[0]; // 假定第一个元素就是最大值
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
}
A01 a01 = new A01();
double[] arr = {1.0, 4.7, 1.8};
System.out.println("arr的最大值=" + a01.max(arr));
但是这样没有考虑代码的健壮性
如果数组传入是空的就会爆出一个越界
所以需要判断保证arr传入进来至少有一个元素
if (arr.length > 0) {
保证这个条件，然后才走这个代码。
}
但是还要求有一个返回值
如果不大于零麻烦了
else {
返回double，返回什么比较合适
可以返回一个包装类Double
}
不满足的时候就可以返回一个null
然后满足的时候正常返回一个double的即可
因为对象是可以为空的
这样语法就过了
然后main中接收包装类对象
Double res = a01.max(arr);
if (res != null) {
System.out.println("arr的最大值=" + res)；
} else {
System.out.println("arr的输入有误");
}
但是这样如果直接传入一个null呢！？
会爆异常
arr.length的时候会有null.length
所以需要额外增加一个条件
arr!=null && arr.length > 0
// 第二题
编写类A02，定义方法find，实现查找某字符串是否在字符串数组中，并返回索引，如果找不到，返回-1
分析：
1、类名 A02
2、方法名find
3、返回值 int
4、形参 String String[]
class A02 {
public int find (String findStr, String[] strs) {
// 直接遍历字符串数组，如果找到，返回索引
for (int i = 0; i < strs.length; i++) {
if (findStr.equals(strs[i])) {
return i;
}
}
return -1;
}
}
String[] strs = {"jack", "tom", "mary", "milan"};
A02 a02 = new A02();
int index = a02.find("hsp", strs);
System.out.println("查找的index=" + index);
同理这些代码都可以完成健壮性的补充
// 3、编写类Book，定义方法updatePrice，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100，更改为100，否则不变
分析：
1、类名 Book
2、属性price,name
3、方法名 updatePrice
4、形参()
5、返回值void
6、提供一个构造器
class Book {
String name;
double price;
public Book(String name, double price) {
this.name = name;
this.price = price;
}
public void updatePrice () {
if (this.price > 150) {
this.price = 150;
} else if(this.price > 100) {
this.price = 100;
}
}
// 显示书籍情况
public void info() {
System.out.println("书名="+this.name+"价格="+this.price);
}
}
Book book = new Book("笑傲江湖", 300);
book.info();
book.updatePrice(); // 更新价格
book.info();
// 4、
class A03 {
public int[] copyArry(int[] oldArr) {
// 在堆中创建一个长度为oldArr.length的数组
int[] newArr = new int[oldArr.length];
// 遍历oldArry，将元素拷贝到newArr中
for (int i = 0; i < oldArr.length; i++) {
newArr[i] = oldArr[i];
}
return newArr;
}
}
int[] oldArr = {10,30,50};
A03 a03 = new A03();
int[] newArr = a03.copyArr(oldArr);
//遍历newArri验证
System.out.println("==返回的newArr元素情况==");
for (int i = 0; i < newArr.length; i++) {
System.out.print(newArr[i] + "\t");
}
// 5、
class Circle {
double radius;
public Circle(double radius) {
this.radius = radius;
}
public double area() {
return Math.PI * radius * radius;
}
public double len() {
return 2 * Math.PI * radius;
}
}
Circle circle = new Circle(3);
System.out.println("面积=" + circle.area());
System.out.println("周长=" + circle.len());
// 6、
编程创建一个Cale计算类，在其中定义2个变量表示两个操作数
定义四个方法实现求和，差，乘，商（要求除数为0的话，要提示）并且创建两个对象，分别测试
class Cale {
double num1;
double num2;
public Cale(double num1, double num2) {
this.num1 = num1;
this.num2 = num2;
}
public double sum() {
return num1 + num2;
}
public double minus() {
return num1 - num2;
}
public Double mul() {
// return num1 * num2;
这里又使用到包装类
if (num2 == 0) {
System.out.println("num2 不能为0");
return null;
} else {
return num1 / num2;
}
}
}
main
Cale cale = new Cale(2, 0);
System.out.println("和=" + cale.sum());
System.out.println("差=" + cale.minus());
System.out.println("乘=" + cale.mul());
Double divRes = cale.div();
if (dieRes != null) {
System.out.println("除=" + divRes);
}
System.out.println("除=" + cale.div());
// 7、略，太简单
// 8、
8、给定一个Java程序的代码如下所示，则编译运行之后，输出结果是什么？
public class Test{
int count = 9;
public void count1() {
count = 10;
System.out.println("count1=" + count);
}
public void count2() {
System.out.println("count2 = " + count++);
}
public static void main(String args[]) {
new Test().count1();
new Test()这里没有使用一个引用，这个对象是一个匿名对象，也是在堆里面，但是这个对象只能使用一次，没有在栈中进行引用。匿名对象就是没有名字的对象。
合起来就是创建好匿名对象之后就调用count1()
将count换成10然后输出10
Test t1 = new Test();
这次会指向堆，产生一个新的对象，原来的匿名对象被销毁了，这个对象的属性为9，依然是这个属性。
t1.count2(); // 这里我写成count1了，哈哈
t1.count2();
}
}
out:
count1 = 10
count1 = 9
count2 = 10
// 9、
class Music {
String name;
int times;
public Music (String name, int times) {
this.name = name;
this.times = times;
}
public void play () {
System.out.println("音乐 " + name + " 正在播放中... 时长为" + times + "秒");
}
public String getInfo() {
return "音乐 " + name + " 播放时间为" + times;
}
}
Music music = new Music("笑傲江湖", 300);
music.play();
System.out.println(music.getInfo());
// 10
试试写出以下代码的运行结果
class Demo {
int i = 100;
public void m() {
int j = i++;
System.out.println("i="+i);
System.out.println("j="+j);
}
}
class Test {
public static void main(String[] args) {
Demo d1 = new Demo();
Demo d2 = d1;
d2.m(); // 101 100
System.out.println(d1.i); // 101
System.out.println(d2.i); // 101
}
}
out：
i=101
j=100
101
101
// 11、
public double method(double d1, double d2) {}
// 12、
class Employee {
String name;
char gender;
int age;
String job;
double sal;
public Employee(String job, double sal) {
this.job = job;
this.sal = sal;
}
public Employee(String name, char gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public Employee(String job, double sal, String name, char gender, int age) {
this(name, gender, age);
// this(job, sal); // 因为this这样用只能放到第一条语句，第一条语句已经有了，后面就不能这样使用了。
this.job = job;
this.sal = sal;
}
}
// 13、
class Circle {
double radius;
public Circle() {}
public Circle(double radius) {
this.radius = radius;
}
public double findArea() {
return Math.PI * radius * radius;
}
// 添加方法setRadius，修改对象的半径值
public void setRadius(double radius) {
this.radius = radius;
}
}
class PassObject {
public void printAreas(Circle c, int times) {
System.out.println("radius\tarea");
for (int i = 1; i <= items; i++) {
c.setRadius(i);
System.out.println((double)i + "\t" + c.findArea());
}
}
}
Circle c = new Circle();
PassObject po = new PassObject();
po.printAreas(c, 5);
// 14、扩展题自己做
import java.util.Random;
import java.util.Scanner;
/*
请编写一个猜拳的游戏
有个人 Tom，设计他的成员变量. 成员方法, 可以电脑猜拳. 电脑每次都会随机生成 0, 1, 2
0 表示 石头 1 表示剪刀 2 表示 布
并要可以显示 Tom的输赢次数（清单）, 假定 玩三次.
*/
// 测试类,主类
public class MoraGame {
// 测试
public static void main(String[] args) {
// 创建一个玩家对象
Tom t = new Tom();
// 用来记录最后输赢的次数
int isWinCount = 0;
// 创建一个二维数组，用来接收局数，Tom出拳情况以及电脑出拳情况
int[][] arr1 = new int[3][3];
int j = 0;
// 创建一个一维数组，用来接收输赢情况
String[] arr2 = new String[3];
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 3; i++) { //比赛3次
// 获取玩家出的拳
System.out.println("请输入你要出的拳（0-拳头，1-剪刀，2-布）：");
int num = scanner.nextInt();
t.setTomGuessNum(num);
int tomGuess = t.getTomGuessNum();
arr1[i][j + 1] = tomGuess;
// 获取电脑出的拳
int comGuess = t.computerNum();
arr1[i][j + 2] = comGuess;
// 将玩家猜的拳与电脑做比较
String isWin = t.vsComputer();
arr2[i] = isWin;
arr1[i][j] = t.count;
// 对每一局的情况进行输出
System.out.println("=========================================");
System.out.println("局数\t玩家的出拳\t电脑的出拳\t输赢情况");
System.out.println(t.count + "\t" + tomGuess + "\t\t" + comGuess + "\t\t" + t.vsComputer());
System.out.println("=========================================");
System.out.println("\n\n");
isWinCount = t.winCount(isWin);
}
// 对游戏的最终结果进行输出
System.out.println("局数\t玩家的出拳\t电脑的出拳\t\t输赢情况");
for (int a = 0; a < arr1.length; a++) {
for (int b = 0; b < arr1[a].length; b++) {
System.out.print(arr1[a][b] + "\t\t\t");
}
System.out.print(arr2[a]);
System.out.println();
}
System.out.println("你赢了" + isWinCount + "次");
}
}
// Tom类
class Tom { // 核心代码
// 玩家出拳的类型
int tomGuessNum; //0,1,2
// 电脑出拳的类型
int comGuessNum; //0,1,2
// 玩家赢的次数
int winCountNum;
// 比赛的次数
int count = 1; //一共比赛3次
public void showInfo() {
//....
}
/**
* 电脑随机生成猜拳的数字的方法
* @return
*/
public int computerNum() {
Random r = new Random();
comGuessNum = r.nextInt(3); // 方法 返回 0-2的随机数
// System.out.println(comGuessNum);
return comGuessNum;
}
/**
* 设置玩家猜拳的数字的方法
* @param tomGuessNum
*/
public void setTomGuessNum(int tomGuessNum) {
if (tomGuessNum > 2 || tomGuessNum < 0) {
//抛出一个异常, 李同学会写，没有处理
throw new IllegalArgumentException("数字输入错误");
}
this.tomGuessNum = tomGuessNum;
}
public int getTomGuessNum() {
return tomGuessNum;
}
/**
* 比较猜拳的结果
* @return 玩家赢返回true，否则返回false
*/
public String vsComputer() {
//比较巧
if (tomGuessNum == 0 && comGuessNum == 1) {
return "你赢了";
} else if (tomGuessNum == 1 && comGuessNum == 2) {
return "你赢了";
} else if (tomGuessNum == 2 && comGuessNum == 0) {
return "你赢了";
} else if (tomGuessNum == comGuessNum){
return "平手";
} else {
return "你输了";
}
}
/**
* 记录玩家赢的次数
* @return
*/
public int winCount(String s) {
count++; //控制玩的次数
if (s.equals("你赢了")) { //统计赢的次数
winCountNum++;
}
return winCountNum;
}
}
二、面向对象中级部分开始
将会讲解的内容：
IntelliJ IDEA
包
访问修饰符
封装
继承
多态
Super
overwrite
Object类详解
断点调试
来看IDEA是什么东西：
IDEA
1、IDE是集成开发环境的意思
IDEA全称是IntelliJ IDEA
2、在业界被公认为最好的Java开发工具
3、IDEA是JetBrains公司的产品，总部位于捷克的首都布拉格
4、除了支持Java开发，还支持HTML，CSS，PHP，MySQL，Python等
除了IDEA还有另外一款集成开发环境
Eclipse介绍
1、Eclipse是一个开发源代码的，基于Java的可扩展开发平台
2、最初是由IBM公司耗资3000万美金开发的下一代IDE开发环境
3、2001年11月贡献给开源社区
4、Eclipse是目前最优秀的Java开发IDE之一
我们先使用IDEA，后面使用Eclipse，因为现在使用最广的是IDEA
国内要么使用IDEA要么使用eclipse
三、IDEA的使用
首先进入官网地址
https://www.jetbrains.com/
点击Download
我这里选择其他版本Other versions
我现在是2025年，我这里选择下载2023年的
左边的Ultimate是旗舰版，右边的Community是社区版
我这里下载旗舰版，后面30天过期了再你懂的。
我下载这个exe
或者使用老韩分享的，我这里直接下载了。
但是老韩建议使用老韩的版本，我这里还是换了。
免得到时候使用这个软件的时候因为版本的不同找半天
https://pan.baidu.com/s/1bzBvf9E6GgNdpaqwxngRfA?pwd=3gk5
今天开始和终端拜拜！！！
四、IDEA的基本使用
使用IDEA可以创建Java项目Project，看看IDEA是如何创建JAVA项目的，创建一个Hello的项目，写一个JAVA文件运行。
开始问你要不要引入一个设置，这里没有直接下一步OK
要不要自定义，直接跳过Skip Remaining and Set Defaults
选择激活还是30天免费，选择Evaluate for free
点击Evaluate
点击这个创建新的项目
这个地方会默认选中我们安装好的JAVA环境
如果没有可以自己添加JDK
选到主目录即可，不用往下面选，然后ok，下一步到下图
如果这个目录没有存在就点击创建
在src下面创建JAva的源码，这里写代码
这里可以修改字体，准确来说是修改编辑器的字体大小
因为代码区也就是编辑区
public class Hello {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
右键运行Ctrl + Shift + F10
五、IDEA的使用技巧和经验
前面调整了编辑区的字体大小，现在我们想要调整菜单和项目区的字体怎么调整呢？
还可以调整粗体
点击Bold
这个地方可以调整编辑区的界面样式
这个地方可以看到当前的编码方式，以后使用UTF-8
这里两个都改成UTF-8
练习：
使用IDEA开发一个Java项目，创建一个类MyTools，编写一个方法，完成对int数组冒泡排序的功能
import java.util.Arrays;
public class MyTools {
public static void main(String[] args) {
BubbleSort bubbleSort = new BubbleSort();
int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 100) + 1;
} // 随机生成数组，大小len = 10
System.out.println("start-------->当前的数组为：" + Arrays.toString(arr));
bubbleSort.sort(arr);
System.out.println("end-------->最终结果：" + Arrays.toString(arr));
}
}
class BubbleSort {
public void sort(int[] arr) {
int arrLen = arr.length;
int compareCount = 0;
int compareSum = 0;
for (int i = 0; i < arrLen-1; i++) { // 需要比较几轮
for (int j = 0,temp = 0; j < arrLen-1-i; j++) { // 最多比较len-1，最少比较1次
if (arr[j] > arr[j+1]) { // 比较代码，升序（从左到右）
compareCount++;
compareSum++;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
if (compareCount == 0) {
System.out.println("数组已有序，直接退出排序程序->out");
break;
}
System.out.println("第" + (i+1) + "轮的结果->" + Arrays.toString(arr));
System.out.println("\t第" + (i+1) + "轮交换的次数->" + compareCount);
compareCount = 0;
}
System.out.println("一共交换了" + compareSum + "次");
}
}
当我们已有项目再次创建项目的时候会弹出这样的窗口，告诉我们是当前窗口创建还是新的窗口创建，自行选择。当前窗口就会覆盖掉，如果是新窗口就会新开一个，两个项目不冲突。
.java自动带上
tip:这里老师的代码我就不写了。
双击这里的ArrayTest.java这个选项图标就可以全屏显示
创建主方法可以直接输入main然后回车，IDEA会自动补全主方法
这里是一个模板语法，后面可以自己配置这些模板
另外一个快捷方式是sout然后回车可以直接得到System.out.println()
值得注意的是这里我们的IDEA使用的时候没有编译直接就能够运行是怎么回事呢？
在IDEA中，当我们run一个文件的时候会先编译成class再运行
当我们运行这个JAVA文件之后这里会突然出现一个out目录
一直点进去会发现有两个类
六、IDEA的快捷键的使用
默认的删除方式是Ctrl Y，但是我们可以自己配置
自己配置可以先remove掉，然后自己配置
如果提示已经分配了，强制自己分配就行了
这里设置成Ctrl + D
我们还可以复制当前行duplicate
这里没有设置，我们自己设置，这里我设置成
Ctrl + Alt + 向下箭头
我们默认有Alt加/的方式进行自动补全，下图
添加注释和取消注释Ctrl /
平时在使用Scanner的时候总是需要导入类，我们怎么快速的导入类呢？
勾选这里的Add unambiguous...和下面的这个Optimize...
快速格式化代码可以使用Ctrl + Shift + L
这里需要注意，如果你的Ctrl + Shift + L和我的这里AMD的热键一样可以设置成Ctrl L
即切换性能记录，然后再再IDEA中使用Ctrl + Shift + L即可
并且我还发现Ctrl+Shift+L弹出了搜索框
发现变成了Ctrl + Alt + L，我们只需要重新设置成Ctrl + Shift + L即可
还有运行代码的快捷键，当前是Shift + F10
设置成为Alt + R
还有快速生成构造器的快捷键，老韩使用的是Alt+insert默认的，这里我设置成为Alt+i
查看类的继承层级关系，将鼠标放到类名上面Ctrl+H就看到了
点击这个会生成一个图
将光标放到一个方法上面输入Ctrl+b会定位到方法，学习继承有帮助
我们可以Ctrl + B放到调用方法的位置，就可以跳转到该方法定义的地方
或者直接Ctrl+鼠标左键即可
再次使用还会自动编号。
练习这些快捷键非常重要，才是专业的JAva程序员。
浙公网安备 33010602011771号