输入输出

import java.util.*;
public class Main {public static void main(String[] args) {int s = 888;String s1 = "Hello World";
//        System.out.print(s);
//        System.out.print(s1);System.out.println(s);System.out.println(s1);Scanner sc = new Scanner(System.in);System.out.print("请输入一个整数：");int num = sc.nextInt();System.out.print("请输入一个字符串：");String s2 = sc.next();System.out.println("输入的数字是：" + num);System.out.println("输入的字符串是" + s2);sc.close();}
}

条件 循环 数组

//输出数组中比平均值大的数
import java.util.*;public class Main {public static void main(String[] args){Scanner sc = new Scanner(System.in);System.out.print("输入数组从长度：");int n = sc.nextInt();int[] arr = new int[n];int sum = 0;for(int i = 0; i < n; i++){arr[i] = sc.nextInt();sum += arr[i];}double avg = (double)sum/n;System.out.println("大于均值的数有：");for(int i = 0; i < n; i++){if(arr[i] > avg)System.out.print(arr[i] + " ");}sc.close();}}

类与对象

//Person.java
public class Person
{String name;int age;public Person(String name, int age){this.name = name;this.age = age;}public void sayHello(){System.out.println("我的名字是： " + name + ", " + "年龄：" + age + "!");}}//main.java
public class Main
{public static void main(String[] args){Person p1 = new Person("张三", 12);Person p2 = new Person("李四", 21);System.out.println("p1的名字是： " + p1.name + ", " + "年龄：" + p1.age + "!");p2.sayHello();}}

继承与多态

//Animal.java
public class Animal
{protected String name;public Animal(String name){this.name = name;}public void makeSound(){System.out.println(name + "Animal makeSound ");}public void introduce(){System.out.println(name + "Animal introduce ");}
}//Dog.java
public class Dog extends Animal
{public Dog(String name){super(name);}@Overridepublic void makeSound(){System.out.println(name + " 说：汪汪汪！");}public void detchBall(){System.out.println(name + "正在捡球");}
}//Cat.java
public class Cat extends Animal
{public Cat(String name){super(name);}@Overridepublic void makeSound(){System.out.println(name + "说：喵喵喵");}public void climbTree(){System.out.println(name + "正在爬树");}
}
//main.java
public class Main {public static void main(String[] args) {Animal a1 = new Dog("狗蛋");Animal [] zoo = {new Dog("小狗1号"),new Dog("小狗2号"),new Cat("小猫1号"),new Animal("动物类")};for(Animal a : zoo){a.introduce();a.makeSound();}}
}

接口与抽象类

//Speakable.java
public interface Speakable {void speak();
}
//Flyable.java
public interface Flyable {void fly();
}
//Robot.java
public abstract class Robot
{protected String name;public Robot(String name){this.name = name;}public void introduce(){System.out.println("Robot:introduce--" + this.name);}public abstract void work();//抽象类里可以有抽象方法和非抽象方法，但是抽象方法没有函数体，分号结尾
}
//TalkRobot.java
public class TalkRobot extends Robot implements Speakable{public TalkRobot(String name) {super(name);}@Overridepublic void speak() {System.out.println(name + "speaking");}@Overridepublic void work(){System.out.println(name + "work is speaking");}
}
//FlyRobot.java
public class FlyRobot extends Robot implements Flyable{public FlyRobot(String name) {super(name);}@Overridepublic void fly() {System.out.println(name + " flying");}@Overridepublic void work(){System.out.println(name + "work is flying");}
}
//AllRoundRobot.java
public class AllRoundRobot extends Robot implements Flyable,Speakable {public AllRoundRobot(String name) {super(name);}@Overridepublic void speak() {System.out.println(name + " speaking");}@Overridepublic void fly() {System.out.println(name + " flying");}@Overridepublic void work() {System.out.println(name + " work is allround");}
}
//Main.java
public class Main {public static void main(String[] args) {Robot r1 = new TalkRobot("小语");Robot r2 = new FlyRobot("小飞");Robot r3 = new AllRoundRobot("小全能");Robot[] robots = {r1, r2, r3};for(Robot robot : robots) {robot.introduce();robot.work();//子类都有work，都想用work，只能用抽象类的抽象方法if(robot instanceof Speakable) {((Speakable) robot).speak();}if(robot instanceof Flyable) {((Flyable) robot).fly();}System.out.println();}}
}运行结果：
Robot:introduce--小语
小语work is speaking
小语speakingRobot:introduce--小飞
小飞work is flying
小飞 flyingRobot:introduce--小全能
小全能 work is allround
小全能 speaking
小全能 flying

特点	接口 (interface)	抽象类 (abstract class)
是否可以有方法实现	只能有抽象方法（Java 8 以前），Java 8+ 支持默认方法	可以有普通方法
是否可以有成员变量	❌不可以	✅可以有成员变量
继承关系	implements 实现接口（可以多实现）	extends 继承抽象类（只能单继承）
是否有构造函数	❌不允许有	✅可以有
能否被实例化	❌ 不能直接实例化	❌ 不能直接实例化
设计目的	描述行为能力	描述“是什么”，有默认行为

抽象类和接口有什么用？
抽象类中定义通用的功能并让子类共享，如Robot及其子类都有introduce，不用每次定义子类都定义一遍，并且由于有抽象类需要子类实现，定义抽象类数组Robot，数组里面可以放Robot的所以子类，并且调用抽象类work的时候，由于子类都重写的work，main就可以统一调用work了
接口也是，统一行为标准，比如两个类Bird和Plane都implements Flyable，并且子类都有fly函数，可以定义Flyable[] (接口也可以作为数据类型定义数组)，然后直接调用各自的fly就好了（如果没有implements Flyable，不认为有Flyable类型，不允许定义）。此外还有第二个用途，就是Java 不支持多继承类，但支持多实现接口：在上面的例子中public class AllRoundRobot extends Robot implements Flyable,Speakable，接口解决了多重能力组合的问题，但是类无法解决。
抽象方法与普通方法的区别：

比较点	抽象方法	普通方法
是否有方法体	❌ 没有	✅ 有
子类是否必须实现	✅ 必须实现	❌ 可以继承直接用
是否可直接调用	❌（只能通过重写后调用）	✅ 直接可调用
修饰符要求	只能写在 abstract class 中	任意类中都可以写
用途	强制子类实现特定方法	提供通用行为，子类可继承使用

抽象方法是为了强制子类去“实现”某个行为：抽象类Robot的子类需要实现各自的work，于是定义抽象函数work
普通方法是为了提供“通用的默认行为：Robot的子类都有introduce这个不变的方法。
instanceof
instanceof 是 Java 中的一个关键字，用于判断一个对象是否是某个类或接口的“实例”或“子类型”。

对象 instanceof 类型

如果对象是该类型或其子类、实现类的实例，返回 true。常见用途是：类型判断 + 强制类型转换（类型转换前先判断）例子如下：判断robot是否有说的能力，如果有，强制转换成Speakable在speak

if(robot instanceof Speakable) {((Speakable) robot).speak();
}

因此有了接口第三个用途：打标签
Java 中接口有时并不要求你实现具体逻辑，它更像是一个“能力标记”或“标签”：

public interface Serializable {} // Java 内置接口，表示“这个对象可以被序列化”public class MyData implements Serializable {// 不需要任何方法，但标记了“我可以被序列化”
}

系统框架通过 instanceof Serializable 判断你是否有这个“能力”，然后做相应处理。

文件读写与异常处理

import java.io.FileWriter;
import java.io.IOException;public class WriteExample {public static void main(String[] args) {try{FileWriter writer = new FileWriter("output.txt");writer.write("Hello, Java 文件写入\n");writer.write("这是第二行文本。\n");writer.close();System.out.println("写入成功");}catch(IOException e){System.out.println("写入错误" + e.getMessage());}}
}import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class ReadExample {public static void main(String[] args) {try{BufferedReader reader = new BufferedReader(new FileReader("output.txt"));String line = null;while((line = reader.readLine()) != null) {System.out.println(line);}reader.close();}catch (IOException e){System.out.println("读取错误" + e.getMessage());}}
}

其中
异常处理

结构块	作用
try {}	放置可能抛出异常的代码
catch (异常类型 e)	捕获并处理指定类型的异常
finally {}	无论是否发生异常，都会执行，常用于关闭资源（如 Scanner、文件等）

try内部无论是否异常都会执行，而只有出现异常的时候会执行catch里面的元素
常见异常类型：

异常类	说明
ArithmeticException	算术异常，如除以 0
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组下标越界
NumberFormatException	字符串转换数字失败
IOException	输入输出异常