头歌面向对象程序设计java实验实训

printf114514

已于 2022-05-25 11:55:23 修改

阅读量1.8k

点赞数 4

分类专栏： java 作业文章标签： java 数据结构

于 2022-05-25 10:44:51 首次发布

本文链接：https://blog.csdn.net/printf1433223/article/details/124961498

版权

作业同时被 2 个专栏收录

2 篇文章 3 订阅

订阅专栏

java

1 篇文章 0 订阅

订阅专栏

实验一语言基础

第一关

import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请给定一个自然数N：");
		int N = sc.nextInt();//获取输入的整数N
		int sum = 1;		
		/*****start*****/
		for(int i = 1;i <= N;i++){
            sum*=i;
        }
		
		
		
		
		
		
		/*****end*****/
		
		System.out.println("自然数N的阶乘为" + sum);
	}
}

第二关

package step2;

public class Test {
	public static void main(String[] args) {
		/*****start*****/
		
		//在这里打印出正三角形 
		for(int i = 0;i < 10;i++){
            for(int j = 0;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		
		
		
		System.out.println("——————————我是华丽的分界线——————————");
		//在这里打印出倒三角形
		for(int i = 9;i >= 0;i--){
            for(int j = 0;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		/*****end*****/
	}
}

第三关

package step3;

import java.util.Arrays;
import java.util.Scanner;

public class HelloWorld {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
		/********** Begin **********/
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < i;j++){
                if(arr[i] < arr[j]){
                    arr[j] = arr[j] + arr[i];
                    arr[i] = arr[j] - arr[i];
                    arr[j] = arr[j] - arr[i];
                }
            }
        }
		System.out.println(Arrays.toString(arr));
		
		
		
		
		
		
		
		
		/********** End **********/
	}
}

第四关

package step4;

import java.util.Scanner;

public class NameSearch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        /********** Begin *********/
        String s = scanner.nextLine();
        String name = scanner.nextLine();
        int a = s.indexOf(name);
        while(a != -1){
            System.out.println(a);
            a = s.indexOf(name,a+1);
        }
        /********** End *********/
    }
}

实验二面向对象

第一关

import java.util.Scanner;

public class Task1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String dogName = sc.next();
        String dogSex = sc.next();
        String dogColor = sc.next();
        String catName = sc.next();
        String catSex = sc.next();
        double catWeight = sc.nextDouble();
        // 通过有参构造函数实例化Dog类对象dog
        // dog调用talk()方法
        // dog调用eat()方法
        /********* begin *********/
        Dog dog=new Dog(dogName,dogSex,dogColor);
        dog.talk();
        dog.eat();
        /********* end *********/
        // 通过有参构造函数实例化Cat类对象cat
        // cat调用talk()方法
        // cat调用eat()方法
        /********* begin *********/
        Cat cat=new Cat(catName,catSex,catWeight);
        cat.talk();
        cat.eat();
        /********* end *********/
    }
}

// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
    /********* begin *********/
    String name;
    String sex;
    public abstract void talk();
    public abstract void eat();
    /********* end *********/
}

// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
    /********* begin *********/
    String color;
    public Dog(String name,String sex,String color){
        this.name=name;
        this.sex=sex;
        this.color=color;
    }
    public void talk(){
        System.out.println("名称："+name+"，性别："+sex+"，颜色："+color+"，汪汪叫");
    }
    public void eat(){
        System.out.println(name+"吃骨头！");
    }
    /********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
    /********* begin *********/
    double weight;
    Cat(String name,String sex,double weight){
        this.name=name;
        this.sex=sex;
        this.weight=weight;
    }
    public void talk(){
        System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"kg，喵喵叫");
    }
    public void eat(){
        System.out.println(name+"吃鱼！");
    }
    /********* end *********/
}

第二关

import java.util.Scanner;

public class Task2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String cName = sc.next();
        String cSex = sc.next();
        int cAge = sc.nextInt();
        String eName = sc.next();
        String eSex = sc.next();
        int eAge = sc.nextInt();
        // 创建测试类对象test
        // 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
        // 通过showEat()方法调用Chinese的eat()方法
        // 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
        // 通过showEat()方法调用English的eat()方法
        /********* begin *********/
        Person test;
        Person person1=new Chinese(cName,cSex,cAge);
        showEat(person1);
        Person person2=new English(eName,eSex,eAge);
        showEat(person2);
        /********* end *********/
        // 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
        // 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
        /********* begin *********/
        Chinese c=(Chinese)person1;
        c.shadowBoxing();
        English e=(English)person2;
        e.horseRiding();
        /********* end *********/
    }

    // 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
    /********* begin *********/
    public static void showEat(Person p){
        p.eat();
    }
    /********* end *********/
}

// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
    /********* begin *********/
    public String name;
    public String sex;
    public int age;
    abstract void eat();
    /********* end *********/
}

// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
    /********* begin *********/
    public String name;
    public String sex;
    public int age;
    Chinese(String name,String sex,int age){
        this.name=name;
        this.sex=sex;
        this.age=age;
    }
    void eat(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国人，我喜欢吃饭！");
    }
    void shadowBoxing(){
        System.out.println(name+"在练习太极拳！");
    }
    /********* end *********/
}

// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
    /********* begin *********/
    public String name;
    public String sex;
    public int age;
    English(String name,String sex,int age){
        this.name=name;
        this.sex=sex;
        this.age=age;
    }
    void eat(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
    }
    void horseRiding(){
        System.out.println(name+"在练习骑马！");
    }
    /********* end *********/
}

实验三集合框架

第一关

package step2;

import java.util.ArrayList;
import java.util.Scanner;

public class HelloWorld {
	
    @SuppressWarnings("unchecked")
	public static void main(String[] args) {
		//获取输入的数据并添加至集合
		Scanner sc = new Scanner(System.in);
		ArrayList list = new ArrayList<>();
        int length = sc.nextInt();
		for(int i =0 ; i< length; i++){
			list.add(sc.next());
		}
		/********** Begin *********/
		list.remove(0);
        list.remove(length-2);
        list.add("hello");
        list.add("educoder");
        list.set(2,"list");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
		
		/********** End **********/
	}
}

第二关

package step4;

import java.util.*;

public class HelloWorld {
	
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		List<String> list = new ArrayList<String>();
        for(int i=0;i<3;i++){
            list.add(sc.next());
        }
        for(int i=0;i<list.size();i++){
            System.out.println("集合的第"+(i+1)+"个数据为："+list.get(i));
        }

	}
	
}

实验四多线程基础

文件一

package step1;
//请在此添加实现代码
/********** Begin **********/
public class ThreadClassOne extends Thread    {
    public int i=0;
    public ThreadClassOne(){
        super();
    }
    public void run(){
        for(i=0;i<10;i++){
            if(i%2==1){
                System.out.print(i+" ");
            }
        }
    }
}
/********** End **********/

文件二

package step1;

//请在此添加实现代码
/********** Begin **********/
public class ThreadClassTwo implements Runnable{
    public int i=0;
    private Thread mythread;
    public void run(){
        for(i=0;i<11;i++){
            if(i%2==0){
                System.out.print(i+" ");
             }
        }
    }
}

/********** End **********/