Java面向对象程序设计

2401_89137271

543人浏览 · 2026-06-08 00:54:04

2401_89137271 · 2026-06-08 00:54:04 发布

Java程序设计

Java
my first coding
public class Test {
    public static void main(){
        int a = 3;
        char b = '中';
        String c = "你好";
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

一、Java语法

1.自增自减运算符

Java
//自增自减运算符
public class Test{
    public static void main(){
        int a = 3;
        int b=a++;
        System.out.println(a);//4
        System.out.println(b);//3

        int c=4;
        int d=++c;
        System.out.println(c);//5
        System.out.println(d);//5
    }
}

2.字符串连接符+

Java
//字符串连接符 +
public class Test{
    public static void main(){
        System.out.println("hello"+"世界");
        int a=5;
        System.out.println("变量a的值是"+a);
    }
}

3.关系运算符

Java
//关系运算符
public class Test{
    public static void main(){
        int a=5;
        System.out.println(a==5);//a的值等于5吗 true
        System.out.println(a!=5);//a的值不等于5吗   false
    }
}

TypeScript
//逻辑运算符
public class Test{
    public static void main(){
        boolean a=true;
        boolean b=false;
        System.out.println(!a); //非真即假
        System.out.println(a&&b);//有假则假
        System.out.println(a||b);//有真则真
    }
}

4.三目运算符

TypeScript
//三目运算符
public class Test{
    public static void main(){
        int score=80;
        String s=score>=60?"及格":"不及格";
        System.out.println(s);
//        System.out.println(score>=60?"及格":"不及格");
    }
}

5.选择结构

Java
选择结构
import java.util.Scanner;
public class Test1 {
    static void main() {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入成绩：");
        double score = s.nextDouble();
        if (score>=90){
            System.out.println("优秀");
        }
        else if (score>=80){
            System.out.println("良好");
        } else if (score>=70) {
            System.out.println("中");
        } else{
            System.out.println("不及格");
        }
    }
}

6.for循环

Java
循环结构-----for循环
//计算1-100的和
public class Test2 {
    static void main() {
        int sum=0;
        for (int i=0;i<=100;i++){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

7.while循环

Java
循环结构---while循环
//计算1-100的和
public class Test2 {
    static void main() {
        int sum=0;
        int i=0;
        while(i<100){
            i++;
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

8.break

Java
break-------终止循环
//输出1-100之间的前三个偶数
public class Test2 {
    static void main() {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                count++;
            }
            if (count == 3) {
                break;
            }
        }
    }
}

9.continue

Java
continue-----跳过本次循环
//输出1-100之间的奇数
public class Test2 {
    static void main() {

        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
               continue;
            }
            System.out.println(i);
            }
        }
    }

10.do...while

Java
do...while循环
//计算1-100的和
public class Test2 {
    static void main() {
        int i=0;
        int sum=0;
        do{
            i++;
            sum+=i;
        }while(i<100);
        System.out.println(sum);
        }
    }

11.switch语句

Java
switch语句
import java.util.Scanner;
public class Test3 {
    static void main() {
        Scanner s = new Scanner(System.in);
        System.out.println("这里有1-4的号码，请选择：");
        int num = s.nextInt();

        switch (num){
            case 1 :
                System.out.println("任务一");
                break;
            case 2 :
                System.out.println("任务二");
                break;
            case 3 :
                System.out.println("任务三");
                break;
            case 4 :
                System.out.println("任务四");
                break;
            default:
                System.out.println("请输入1-4数字");
        }
    }
}

二、面向对象

1.方法（4种类型）

Java
方法（无参无返回值）
public class Test4 {
    static void main() {
       fun1();
    }
    public static void fun1(){
        int sum = 0;
        for (int i = 0;i<=100;i++){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

Java
无参有返回值
public class Test4 {
    static void main() {
      int num= fun1();
        System.out.println(num);
    }
    public static int fun1(){
        int sum = 0;
        for (int i = 0;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}

Java
有参无返回值
public class Test4 {
    static void main() {
      int n=5;
      fun1(n);
    }
    public static void fun1(int n){
        int sum = 0;
        for (int i = 0;i<=n;i++){
            sum+=i;
        }
        System.out.println(sum);
    }
}

Java
有参有返回
public class Test4 {
    static void main() {
      int num=fun1(1,5);
        System.out.println(num);
    }
    public static int fun1(int n,int m){
        int sum = 0;
        while(n<=m){
            sum+=n;
            n++;
        }return sum;
    }
}

2.引用传递

TypeScript
引用传递（传过来的是person在堆内存中的地址）
public class Test1 {
    public static void main() {
        Person person=new Person();
        person.name="jane";
        fun(person);
        System.out.println(person.name);
    }
    public static void fun(Person person) {
        person.name="kitty";
        System.out.println(person.name);//结果：kitty kitty
    }
}

3.值传递

Java
值传递
public class Test1 {
    public static void main() {
       int a=5;
       fun(a);
        System.out.println(a);
    }
    public static void fun(int b) {
        b=10;
        System.out.println(b);
    }
}

3.构造方法（constructor）

概念

TypeScript
public class Person {
        private String ID;
        private String gender;

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
                "ID='" + ID + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }

    public Person(String ID,String gender) {
        this.ID = ID;
        this.gender=gender;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }
}

4.方法重载

概念
一个类中的多种方法，方法名相同，参数不同

Java
public class Test2 {
    static void main() {
        fun(3,6);
    }
    public static void fun(int a,int b){
        int sum=a+b;
        System.out.println(sum);
    }
    public static void fun(int a,double b){

    }
    public static void fun(double a,double b){

    }
    public static void fun(double a,int b){

    }
}

构造方法重载

getter = 拿值（取东西要返回）

setter = 赋值（放东西）

5.static关键字

概念

6.包

import(同一个包下不用，不同包下用)

7.封装

变量用private隐藏，禁止外部直接修改

提供set/get方法间接访问

方法内可做数据校验，保证数据安全

TypeScript
// 封装：私有成员 + 公开get/set
public class Student {
    // 私有成员变量，外部无法直接访问
    private String name;
    private int age;

    // set赋值
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        // 数据校验，控制合法范围
        if(age > 0 && age < 150){
            this.age = age;
        }
    }

    // get取值
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

// 测试
class Test{
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("小李");
        stu.setAge(18);

        System.out.println(stu.getName());
        System.out.println(stu.getAge());
    }
}

8.继承

概念

9.方法的重写/覆写（overwrite/override）

10.访问权限控制符

11.Object类常用方法

toString

equals(Obiect obj)

TypeScript
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写toString
    @Override
    public String toString() {
        return "姓名：" + name + "，年龄：" + age;
    }

    // 重写equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && name.equals(person.name);
    }

    // 重写hashCode
    @Override
    public int hashCode() {
        return name.hashCode() + age;
    }
}

class Test {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 20);
        Person p2 = new Person("张三", 20);

        // toString
        System.out.println(p1);

        // equals
        System.out.println(p1.equals(p2));

        // hashCode
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());

        // getClass
        System.out.println(p1.getClass());
    }
}

Python
输出结果
姓名：张三，年龄：20
true
数值一致
数值一致
class Person

12.对象转型

父类引用指向子类对象（向上转型）

向下转型

点击图片可查看完整电子表格

TypeScript
// 父类
class Person {
    public void say() {
        System.out.println("普通人说话");
    }
}

// 子类
class Student extends Person {
    @Override
    public void say() {
        System.out.println("学生发言");
    }
    // 子类独有方法
    public void study() {
        System.out.println("专心学习");
    }
}

public class CastTest {
    public static void main(String[] args) {
        // 1.向上转型：父类引用指向子类对象
        Person p = new Student();
        p.say(); //学生发言
        // p.study(); 无法调用子类独有方法

        // 2.向下转型：强制转回子类类型
        Student s = (Student) p;
        s.study(); //专心学习

        // 3.类型判断，避免转型异常
        if (p instanceof Student) {
            Student stu = (Student) p;
            stu.study(); //专心学习
        }
    }
}

13.多态

在方法调用时自动识别所调用方法的对象，并根据实际对象去调用相应方法。

如果满足以下三个条件，那么构成多态：继承、方法的重写、父类引用指向子类对象

TypeScript
// 父类
class Animal {
    public void eat() {
        System.out.println("动物进食");
    }
}

// 子类1
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗狗吃骨头");
    }
}

// 子类2
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫咪吃鱼");
    }
}

// 测试
public class PolymorphismTest {
    public static void main(String[] args) {
        // 父类引用指向子类对象，向上转型
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        // 调用重写方法，执行子类逻辑
        a1.eat();
        a2.eat();
    }
}

14.abstract关键字

Java
// 抽象父类
abstract class Animal {
    // 抽象方法：无方法体，子类必须重写
    public abstract void cry();

    // 普通成员方法
    public void sleep(){
        System.out.println("动物睡觉");
    }
}

// 子类继承抽象类
class Dog extends Animal {
    // 强制重写抽象方法
    @Override
    public void cry() {
        System.out.println("汪汪叫");
    }
}

class Cat extends Animal {
    @Override
    public void cry() {
        System.out.println("喵喵叫");
    }
}

// 测试
public class TestAbstract {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.cry();
        dog.sleep();
        cat.cry();
    }
}

15.接口

Python
// 动物叫声接口，规定必须会叫
public interface Animal {
// 抽象方法，只有声明没有实现
void shout();
}

TypeScript
// 狗实现接口
class Dog implements Animal{
    @Override
    public void shout() {
        System.out.println("汪汪汪");
    }
}

// 猫实现接口
class Cat implements Animal{
    @Override
    public void shout() {
        System.out.println("喵喵喵");
    }
}

Java
public class Test {
    public static void main(String[] args) {
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        a1.shout();
        a2.shout();
    }
}

16.final关键字

1. final 修饰类 → 类不能被继承

Plain Text
// final 类：不能有子类
final class Animal {
}
// 报错！无法继承 final 类
// class Dog extends Animal { }

2. final 修饰方法 → 方法不能被重写

Plain Text
class Person {
// final 方法：子类不能重写
public final void run() {
System.out.println("人在跑");
}
}
class Student extends Person {
// 报错！不能重写 final 方法
// public void run() {
}
}

3. final 修饰变量 → 变量只能赋值一次

Plain Text
class Test {
public static void main(String[] args) {
// 1. final 基本类型变量：值不能改
final int AGE = 18;
// AGE = 20; 报错！不能修改
// 2. final 引用类型变量：地址不能改
final Student stu = new Student();
// stu = new Student(); 报错！地址不能改}}

三、数组和异常

1.数组

TypeScript
public class ArrayExample {
    public static void main(String[] args) {

        // 1. 定义一个 int 类型数组（存放数字）
        int[] numbers = {10, 20, 30, 40, 50};

        // 2. 定义一个 String 类型数组（存放文字）
        String[] fruits = {"苹果", "香蕉", "橙子", "西瓜"};

        // 3. 访问数组元素（从 0 开始数）
        System.out.println("数字数组第1个元素：" + numbers[0]); // 10
        System.out.println("水果数组第3个元素：" + fruits[2]); // 橙子

        // 4. 遍历数组（把所有元素打印出来）
        System.out.println("\n遍历数字数组：");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

2.异常

抛出与捕获

Java
public class Test1{
    public static void main(String[] args) {
        // ========== 例子1：算术异常（除零错误） ==========
        int a = 10;
        int b = 0;
        try {
            // 可能出错的代码放在 try 里
            int result = a / b; // 这里会触发：ArithmeticException
            System.out.println(result);
        } catch (ArithmeticException e) {
            // 捕获到异常后执行这里
            System.out.println("捕获到算术异常：不能除以 0");
            // 打印异常详细信息（调试用）
            e.printStackTrace();
        }
        // ========== 例子2：数组越界异常 ==========
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[5]); // 下标只有 0、1、2，访问 5 会报错
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到数组越界异常：下标超出数组范围");
            e.printStackTrace();
        }
        System.out.println("程序正常结束～");
    }
}

try...catch

throw与throws

throws：方法声明抛出异常（被动抛出）

Java
public class ThrowThrowsDemo {
    // throws 声明该方法可能抛出算术异常
    public static void div(int a, int b) throws ArithmeticException {
        int res = a / b;
        System.out.println("计算结果：" + res);
    }

    public static void main(String[] args) {
        try {
            div(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("捕获除数为0异常");
        }
    }
}

throw：手动主动抛出异常

TypeScript
public class ThrowThrowsDemo {
    public static void checkAge(int age) {
        if (age < 18) {
            // 手动抛出异常对象
            throw new RuntimeException("年龄未满18岁，禁止访问");
        }
        System.out.println("年龄校验通过");
    }

    public static void main(String[] args) {
        try {
            checkAge(16);
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }
    }
}

四、常用实用类

1.String

==比较的是地址

Equals 比较的是值(String默认重写equals方法）

String常用方法

StringBuffer

可变长字符串

append(参数) 在字符串后面添加内容

TypeScript
public class Buffertest {
    static void main() {
        StringBuffer stringBuffer=new StringBuffer();
        stringBuffer.append("abc");
        stringBuffer.append("123");
        stringBuffer.append(true);
        System.out.println(stringBuffer);
        String s = stringBuffer.toString();//字符串转换，把任何数据
        类型的转换为字符串
        s = String.valueOf(s);
        System.out.println(s);
    }
}

2.Math

Java
import java.util.Random;

public class Testmath {
    static void main() {
        System.out.println(Math.round(3.56));//四舍五入
        System.out.println(Math.random());
        Random r = new Random();
        System.out.println(r.nextInt(1000));
    }
}

3.基本数据类型包装类

4.File

File类常用方法

5.增强for循环

语法格式

Java
public class Testfor {
    public static void main(){
        int[] a = {1,2,3,4,5};
        //方法一
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        System.out.println("\n");
        //方法二
        for (int value:a){
            System.out.println(value); //value代表循环当中的每一个变量
        }
    }
}

五、集合

1.集合

C++
import java.util.HashSet;
import java.util.Set;

public class Testcollection {
    static void main() {
        Set set = new HashSet();//无序，不重复
        set.add("hello");
        set.add(345);
        set.add(5.37);
        set.add("是");
        System.out.println(set); //结果[5.37,345,hello,是] HashSet重写了toString方法
    }
}

2.Collection(接口)常用方法

C++
public class Testcollection {
    static void main() {
        Set set = new HashSet();//无序，不重复
        set.add("hello");
        set.add(345);
        set.add(5.37);
        set.add("是");
        Iterator iter = set.iterator();
        while (iter.hasNext()){
            Object obj=iter.next();
            System.out.println(obj);
        }
    }
}

从数据结构看ArrayList和LinkedList

Java
import java.util.ArrayList;
import java.util.List;

public class Testlist {
    static void main() {
        List list = new ArrayList();
        list.add(123);
        list.add(345);
        list.add("张三 ");
        list.add(3.45);
        for(int i = 0;i<list.size();i++){
            Object o = list.get(i);
            System.out.println(o);
        }
        for(Object o:list){
            System.out.println(o);
}
    }
}

3.泛型（通用类型）

让一段代码可以适配多种数据类型，同时保留类型安全。

TypeScript
public class Test {
    // 泛型方法
    public static <T> void printArray(T[] arr) {
        for (T item : arr) System.out.println(item);
    }

    public static void main(String[] args) {
        // 1. 打印 int
        Integer[] nums = {1,2,3};
        printArray(nums);

        // 2. 打印 String
        String[] strs = {"张三","李四","王五"};
        printArray(strs);
    }
}

4.collections（类）

Java
package com.daily.AbstractTest;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestCollectons {
    static void main() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(23);
        list.add(34);
        list.add(33);
        list.add(89);
        list.add(67);
        //随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //升序排序
        Collections.sort(list);
        System.out.println(list);
        //降序排序
        Collections.reverse(list);
        System.out.println(list);

    }
}

5.Map

示例

Java
import java.util.HashMap;
import java.util.Map;

public class TestMap {
    static void main() {
    //以年龄为键，姓名为值
        Map<Integer,String> w = new HashMap<>();
        //添加数据：键和值的类型必须与上面定义的泛型一致
        w.put(18,"zhangsan");
        w.put(34,"lisi");
        //获取数据：根据键获取对应的值
        String name = w.get(34);
        System.out.println("年龄34的人叫"+name);
    }
}

练习题

Java
package com.daily.test2;

public class Worker {
    private String name;
    private int age;
    private double salary;
    public Worker(){

    }

    public Worker(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    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;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void work(){
        System.out.println(name+"正在工作中");
    }
}

Java
package com.daily.test2;

import java.util.ArrayList;
import java.util.List;

public class Homework {
    public static void main(){
    h1();
    }
    public static void h1(){
        List<Worker> workers = new ArrayList<Worker>();
        workers.add(new Worker("zhangsan",18,3000));
        workers.add(new Worker("lisi",25,3500));
        workers.add(new Worker("wangwu",22,3200));
        workers.add(1,new Worker("zhaoliu",24,3300));
        workers.remove(3);
        for(Worker w:workers){
            System.out.println(w.getName()+" "+w.getAge()+" "+w.getSalary() +" ");
        }
    }
}

Java
package com.daily.test2;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Maptest {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        h2(sc.nextInt());

    }
    public static void h2(Integer year){
        Map<Integer,String> m = new HashMap<>();
        m.put(1982,"意大利");
        m.put(1986,"阿根廷");
        m.put(1990,"西德");
        m.put(1994,"巴西");
        m.put(1998,"法国");
        m.put(2002,"巴西");
        m.put(2006,"意大利");
        m.put(2010,"西班牙");
        if(m.get(year)!=null){
            System.out.println(m.get(year));
        }else
            System.out.println("这一年，没有举办世界杯！");
    }
}

TypeScript
import java.util.*;

public class Maptest {
    public static void main(String args[]){
        h3();
    }
    public static void h3(){
        Map<String,String> teacher = new HashMap<>();
        teacher.put("Tom","CoreJava");
        teacher.put("John","Orale");
        teacher.put("Susan","Orale");
        teacher.put("Jerry","JDBC");
        teacher.put("Jim","Unix");
        teacher.put("Kevin","JSP");
        teacher.put("Lucy","JSP");
        teacher.put("Allen","JDBC");
        teacher.put("Lucy","CoreJava");
        //entrySet()：这个方法会将 Map 中的所有键值对打包成一个 Set 集合返回
        //iterator() 方法，生成了一个专门用于遍历这个 Set 集合的游标（迭代器）。
        Iterator<Map.Entry<String, String>> iter = teacher.entrySet().iterator();
        //while (iter.hasNext()) 会不断检查迭代器后面是否还有下一个元素。如果有，就继续循环。
        while (iter.hasNext()){
            //iter.next() 会让游标向下移动一步，并取出当前的键值对对象（
            Map.Entry<String,String> entry = iter.next();
            System.out.println(entry.getKey()+" "+entry.getValue());
            if(entry.getValue().equals("JSP")){
                System.out.println("\n");
                System.out.println(entry.getKey());
            }
        }
    }
}

六、输入输出流（I/O）

1.文件字节流

Java
package com.daily.test2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class iotest {
    static void main() {
        try {
            InputStream is = new FileInputStream("D://TestMap.java");
            int a;
            while(true){
                try {
                    if (!((a= is.read())!=-1)) break;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                System.out.print((char)a);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }

    }
}

文件字节输入输出流

Java
边读边写
package com.daily.test2;

import java.io.*;

public class TestOutputstream {
    static void main() {
        File file = new File("D:/test/abc/abc.txt");
        if(!file.exists()){
            file.getParentFile().mkdirs();
            try {
                file.createNewFile();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        try {
            FileInputStream fls = new FileInputStream("D:/TestMap.java");
            FileOutputStream fl = new FileOutputStream("D:/test/abc/abc.txt");
            int a;
            while((a=fls.read())!=-1){
                fl.write(a);
            }
            fls.close();
            fl.close();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

2.文件字符流

输入流

Java
package com.daily.test2;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestFileReader {
    static void main() {
        try {
            FileReader re = new FileReader("D:/TestMap.java");
            int a;
            while ((a=re.read())!=-1){
                System.out.print((char) a);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

输出流

Java
package com.daily.test2;

import java.io.FileWriter;
import java.io.IOException;

public class TestFileWriter {
    static void main() {
        try {
            FileWriter fw = new FileWriter("D:/test/abc/a.txt");
            fw.write("this is a test");
            fw.write("\r\n");
            fw.write("this is another test");
            fw.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3.缓冲流

Java
package com.daily.test2;

import java.io.*;

public class TestBufferd {
   public static void main(String[] args) {

        try {
            FileWriter fw = new FileWriter("D:/test/abc/a.txt");
            BufferedWriter br = new BufferedWriter(fw);
            for(int i = 0;i<10;i++){
                br.write(Math.random() + "");
                br.newLine();
            }
            //先关包装流，再关底层流
            br.close();
            fw.close();
            BufferedReader bw = new BufferedReader(new FileReader("D:/test/abc/a.txt"));
            String line;
            while((line=bw.readLine())!=null){
                System.out.println(line);

            }
            bw.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

4.转换流

Java
package com.daily.test2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Testtransfer {
    public static void main(String[] args){
    //相当于Scanner，从键盘获取内容
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            String s = br.readLine();
            System.out.println("接受的内容是："+s);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

练习

Java
package com.daily.test2;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Homework_1 {
    public static void main(String[] args){
        try {
            //创建文件读取流
            BufferedReader br = new BufferedReader(new FileReader("D:/homework.txt"));
            String line=null; //存储每一行读到的内容
            List<Worker_1> ls =new ArrayList<Worker_1>();// 创建集合，存员工对象
            while((line= br.readLine())!=null){ //readLine()：读一行文本 null表示读完了
                String arr[]=line.split(" ");
                Worker_1 worker1 = new Worker_1();
                worker1.setName(arr[0]);//姓名：字符串直接赋值
                worker1.setAge(Integer.parseInt(arr[1]));// 年龄：字符串转int
                worker1.setSalary(Double.parseDouble(arr[2])); // 工资：字符串转double
                ls.add(worker1);// 把员工对象放进集合里
            }
            for(Worker_1 worker1:ls){
                System.out.println(worker1);
            }
            br.close(）;

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
class Worker_1{
    String name;
    int age;
    double salary;

    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;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return name+" "+age+" "+salary;
    }
}

七、线程

1.进程和线程

2.Java实现多线程

继承Thread类

Java
package com.daily.test2;

public class Test {
    static void main() {
        //创建自定义的线程类对象
        MyThread myThread = new MyThread();
        myThread.currentThread().setName("Mythread");
        //主线程命名
        Thread.currentThread().setName("main");
        //开启子线程
        myThread.start();
        for(int i= 0;i<10;i++){
            System.out.println(myThread.currentThread().getName()+i);
        }
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

实现Runnable接口

Java
package com.daily.test2;

class ThreadMy implements Runnable{
    @Override
    public void run() {
        for (int i= 0;i<10;i++)
        System.out.println("Threadmy"+i);
    }
}
public class Te {
    static void main() {
        ThreadMy threadMy =new ThreadMy();//创建任务
        Thread t = new Thread(threadMy);//把任务丢给线程
        t.start();//启动线程
        for (int i=0;i<10;i++){
            System.out.println("main:"+i);
        }

    }
}

练习

Java
继承Thread类
package com.daily.test2;

public class Ticket extends Thread{
    static int ticketNum=1;

    @Override
    public void run() {
        for(int i= 0;i<20;i++)
        if(ticketNum<=20){
            System.out.println(this.getName()+"已售卖"+(ticketNum++)+"号票");
        }
    }
}
class Testticket{
    static void main() {
        Ticket t1=new Ticket();
        Ticket t2=new Ticket();
        Ticket t3=new Ticket();
        t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");
        t1.start();
        t2.start();
        t3.start();

    }
}

Java
实现Runnable接口
package com.daily.test2;

public class Ticket_1 implements Runnable{
    static int Ticketnum=1;

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if(Ticketnum<=10){
                System.out.println(Thread.currentThread().getName()+"售卖了"+(Ticketnum++)+"号票");
            }
        }
    }
}
class Test_2{
    static void main() {
        Ticket_1 tw = new Ticket_1();
        Thread t1 = new Thread(tw);
        Thread t2 = new Thread(tw);
        Thread t3 = new Thread(tw);
        t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");
        t1.start();
        t2.start();
        t3.start();

    }
}

3.线程的生命周期

4.Thread常用方法

5.线程同步

死锁

Java
package com.daily.test2;

public class DeadLock extends Thread{
    public static Object o1 = new Object();
    public static Object o2 = new Object();
    public boolean flag = true;

    @Override
    public void run() {
        if (flag) {
        synchronized (o1){
            try {
                sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("o1");
            synchronized (o2){
                System.out.println("o2");
            }
        }
        }else{
            synchronized (o2){
                try {
                    sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("o2");
                synchronized (o1){
                    System.out.println("o1");
                }
            }
        }
        }
    }

class test{
    static void main() {
        DeadLock d1 = new DeadLock();
        DeadLock d2 = new DeadLock();
        d1.flag=false;
        d1.start();
        d2.start();
    }
}