程序设计编程题目（持续更新）

梦？尘

已于 2023-03-13 16:38:32 修改

阅读量733

点赞数 1

文章标签： c++ 开发语言

于 2023-02-19 11:03:50 首次发布

本文链接：https://blog.csdn.net/qq_55671900/article/details/129108449

版权

c语言题目

春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，它是这样定义的：“水仙花数”是指一个3位数，它的各位数字的立方和等于其本身，比如，153=
13 +53+33。现在要求输出所有在m和n范围内的水仙花数。提示：
由题目中的数据范围，[100，999]，可知每个数（都是3位数），那只需令a,b,c分别等于这3个数，然后求出a,b,c的立方和看是否等于这个3位数，如果是，则这个数就是水仙花数。
若想知道某个区间内的水仙花数有多少个，那只需要枚举这个区间内的所有数，统计水仙花数的个数即可。

#include<stdio.h>
int main(){
    int i,a,b,c,count=0;
    for(i=100;i<1000;i++){
        a=i%10;      //各位
        b=i/10%10;   //十位
        c=i/100%10;  //百位
        if(a*a*a+b*b*b+c*c*c==i){
            printf("%d ",i);
            count++;
        }
    }
    printf("\n");
    printf("个数为%d ",count);
    return 0;
}

完数的定义：如果一个大于1的正整数的所有因子之和等于它的本身，则称这个数是完数，比如6，28都是完数：6 =1+2+3；28
=1+2+4+7+14。本题的任务是判断两个正整数之间完数的个数。

#include <stdio.h>

int main()
{
    int num1, num2, i, j, sum, count = 0;
    printf("请输入两个正整数：");
    scanf("%d %d", &num1, &num2);
    for (i = num1; i <= num2; i++)
    {
        sum = 0;
        for (j = 1; j < i; j++)
        {
            if (i % j == 0)
            {
                sum += j;
            }
        }
        if (sum == i)
        {
            count++;
        }
    }
    printf("%d和%d之间有%d个完数\n", num1, num2, count);
    return 0;
}

求两个非负整数的最大公约数

int gcd(int p,int q){
    if(q==0) return p;
    int r= p % q;
    return gcd(q,r);

}

int main(){
        int num1,num2,result;
        printf("请输入两个正整数：");
        scanf("%d %d", &num1, &num2);
        result=gcd(num1,num2);
        printf("%d",result);
}

整数划分问题（将一个正整数n拆成一组数连加并等于n的形式，且这组数中的最大加数不大于n）

/**
 *   整数划分问题是将一个正整数n拆成一组数连加并等于n的形式，且这组数中的最大加数不大于n。
 *   即：n=n1+n2+…+nk;
 *   经典分治算法
*/
#include<stdio.h>

int q(int n,int m){                             //n表示正整数，m表示最大加数
    if(n<1||m<1) return 0;
    if(n<m) return q(n,n);
    if(n==m) return q(n,m-1)+1;
    return q(n-m,m)+q(n,m-1);
}

void main()
{
    int n;
    printf("请输入你要划分的整数:");
    scanf("%d",&n);
    printf("该正整数可以划分 %d  个",q(n,n));

}

Java语言题目

生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）

package homework;


/*
 * 1.生活中的通过代理访问网络，
 * 客户通过网络代理连接网络（具体业务），
 * 由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）
 */

public class Client1 {
	public static void main(String[] args) {
		Proxy proxy=new Proxy();
		proxy.connect();
	}

}

//抽象主题：网络
interface Network{
	void connect();//连接网络
}

//真实主题
class Net implements Network{
	@Override
	public void connect() {
		// TODO Auto-generated method stub
		System.out.println("连接网络成功，可以冲浪了！");
	}
}

//代理
class Proxy implements Network{
	private Net net;
	@Override
	public void connect() {
		// TODO Auto-generated method stub
		if(net==null)
			net=new Net();
		 gainPower();
		 gainSet();
		 net.connect();
	}
	public void gainPower() {
		System.out.println("获取用户权限......");
	}
	
	public void gainSet() {
		System.out.println("开放访问限制......");
	}
}

在这里插入图片描述

机器人会移动跟说话。狗狗会汪汪叫跟奔跑。用适配器模式实现机器人模仿狗狗叫跟跑。

package homework;


/*
 * 机器人会移动跟说话。狗狗会汪汪叫跟奔跑。
 * 用适配器模式实现机器人模仿狗狗叫跟跑。
 */

public class Client2 {
	public static void main(String[] args) {
		Dog dog=new Dog();
		Robot robot=new Adapter(dog);
		robot.Talk();
		System.out.println();
		robot.Move();
	}

}

//目标接口:robot机器人
interface Robot{
	public void Talk();
	public void Move();
}


//适配者 
class Dog{
	public void bark() {
		System.out.println("开始汪汪叫......");
	}
	
	public void run() {
		System.out.println("开始跑起来了......");
	}
}

//适配器（对象适配器）
class Adapter implements Robot{
	private Dog dog;

	public Adapter(Dog dog) {
		super();
		this.dog = dog;
	}
	
	@Override
	public void Talk() {
		// TODO Auto-generated method stub
		System.out.println("机器人开始模仿狗狗叫......");
		dog.bark();
		
	}
	@Override
	public void Move() {
		// TODO Auto-generated method stub
		System.out.println("机器人开始模仿狗跑了起来......");
		dog.run();
		
	}
	
}

在这里插入图片描述

使用桥接模式使用充电宝和充电器分别给手机和蓝牙耳机进行充电

package homework;

/*
 * 使用桥接模式使用充电宝和充电器分别给手机和蓝牙耳机进行充电。
 */

public class Client3 {
	public static void main(String[] args) {
/One
		// 创建具体实现化角色
		ChargeQuipment chargequipment1=new PortableBattery();
		// 创建扩展抽象化角色
		Equipment equipment1=new Phone(chargequipment1);
		equipment1.show();
		System.out.println();
/Two
		// 创建具体实现化角色
		ChargeQuipment chargequipment2=new Charger();
		// 创建扩展抽象化角色
		Equipment equipment2=new BluetoothHeadset(chargequipment2);
		equipment2.show();
	}

}

//实现化角色
interface ChargeQuipment{
	public void charging();
}

//具体实现化角色1:充电器
class Charger implements ChargeQuipment{
	@Override
	public void charging() {
		// TODO Auto-generated method stub
		System.out.println("使用充电器开始充电......");
		
	}
}

//具体实现化角色2:充电宝
class PortableBattery implements ChargeQuipment{
	@Override
	public void charging() {
		// TODO Auto-generated method stub
		System.out.println("使用充电宝开始充电......");
		
	}
}


//抽象化角色
abstract class Equipment {
	// 包含实现化角色的引用
	protected ChargeQuipment chargeQuipment;

	// 通过构造方法进行初始化
	protected Equipment(ChargeQuipment chargeQuipment) {
		super();
		this.chargeQuipment = chargeQuipment;
	}
	
	// 定义抽象方法
	public abstract void  show();

	
}

扩展抽象化角色
class Phone extends Equipment{
	protected Phone(ChargeQuipment chargeQuipment) {
		super(chargeQuipment);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println( "手机");
		chargeQuipment.charging();
	}
}

class BluetoothHeadset extends Equipment{
	
	protected BluetoothHeadset(ChargeQuipment chargeQuipment) {
		super(chargeQuipment);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println( "蓝牙耳机");
		chargeQuipment.charging();
	}
}

在这里插入图片描述

编写程序展示一个学校院系结构。
需求：要在一个页面中展示除学校的院系组成，
一个学校有多个学院，一个学院有多个系。使用的是透明组合模式

package combination;

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

public class Client {
	
	public static void main(String[] args) {
		// 从大到小的结构来创建
		
		// 创建对象大学
		UniversityComponent university = new University("清华大学", "中国顶级大学");
		
		// 创建学院
		UniversityComponent computerCollege = new College("计算机学院", "计算机学院很厉害");
		UniversityComponent infoEngineerCollege = new College("信息工程学院", "信息工程学院也不错");
		
		// 创建各学院下的系并添加进各学院
		computerCollege.add(new Department("软件工程", "软件工程贼厉害"));
		computerCollege.add(new Department("计算机科学与技术", "计科是老牌专业"));
		
		infoEngineerCollege.add(new Department("通信工程", "通信工程不好学"));
		infoEngineerCollege.add(new Department("信息工程", "信息工程好学"));
		
		// 将学院添加进大学
		university.add(computerCollege);
		university.add(infoEngineerCollege);
		
		 university.print();
//		computerCollege.print();
	}
}

//2.树枝角色 Composite 可以管理系
 class College extends UniversityComponent{
	List<UniversityComponent> children = new ArrayList<UniversityComponent>();
	
	public College(String name, String des) {
		super(name, des);
	}
	
	@Override
	public void add(UniversityComponent c) {
		children.add(c);
	}

	@Override
	public void remove(UniversityComponent c) {
		children.remove(c);
	}
	@Override
	public void print() {
		// 学院名字
		System.out.println("--------"+ getName() + "-----------");
		// 遍历子节点,将系信息输出
		for(UniversityComponent c : children){
			c.print();
		}
	}
}

//3. 树叶角色 Leaf 无子节点
 class Department extends UniversityComponent{

	public Department(String name, String des) {
		super(name, des);
	}

	@Override
	public void print() {
		System.out.println(getName());
	}

}
//树枝角色 Composite,可以管理College
 class University extends UniversityComponent{
	List<UniversityComponent> children = new ArrayList<UniversityComponent>();
	
	public University(String name, String des) {
		super(name, des);
	}
	
	@Override
	public void add(UniversityComponent c) {
		children.add(c);
	}

	@Override
	public void remove(UniversityComponent c) {
		children.remove(c);
	}
	@Override
	public void print() {
		// 大学名字
		System.out.println("--------"+ getName() + "-----------");
		// 遍历子节点,将学院信息输出
		for(UniversityComponent c : children){
			c.print();
		}
	}
	
}

 
//1. 抽象构件
abstract class UniversityComponent {
	private String name;
	private String des;
	public UniversityComponent(String name, String des) {
		super();
		this.name = name;
		this.des = des;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getDes() {
		return des;
	}
	public void setDes(String des) {
		this.des = des;
	}
	
	// 添加子节点
	public void add(UniversityComponent c){
		// 默认实现
		throw new UnsupportedOperationException();
	}
	
	// 删除子节点
	public void remove(UniversityComponent c){
		// 默认实现
		throw new UnsupportedOperationException();
	}
	
	public abstract void print();
}

在这里插入图片描述

使用组合模式描述商场的服装店，专卖店，衣服，裤子的关系

package homework;



/*
 * 使用组合模式描述商场的服装店，
 * 专卖店，衣服，裤子的关系
 */

import java.util.*;

public class Client1 {
	public static void main(String[] args) {
		ClothingComponent clothing1=new Clothing("衣服专卖店",2);
		clothing1.add(new ClothingItem("男装衣服",3));
		clothing1.add(new ClothingItem("女装衣服",3));
		ClothingComponent clothing2=new Clothing("裤子专卖店",2);
		clothing2.add(new ClothingItem("男装裤子",3));
		clothing2.add(new ClothingItem("女装裤子",3));
		ClothingComponent clothing=new Clothing("服装专卖店",1);
		clothing.add(clothing1);
		clothing.add(clothing2);
		clothing.print();
	}

}

//抽象构件
abstract class ClothingComponent {
	protected String name;
	protected int level;
	
	
	// 添加子节点
	public void add(ClothingComponent c){
		throw new UnsupportedOperationException();
	}
	


	// 删除子节点
	public void remove(ClothingComponent c){
		throw new UnsupportedOperationException();
	}
	// 获取子节点
	public ClothingComponent getChild(int level) {
		throw new UnsupportedOperationException();
	}
	
	public String getName() {
		return name;
	}
	public abstract void print();
}

//2.树枝角色
class Clothing extends ClothingComponent{
	
	
	private ArrayList<ClothingComponent> list = new ArrayList<ClothingComponent>();// 将子节点存储在list里
	
	public Clothing(String name ,int level) {
		this.name=name;
		this.level=level;
	}
	
	public void add(ClothingComponent c){
		list.add(c);
	}
	
	// 删除子节点
	public void remove(ClothingComponent c){
		list.remove(level);
	}
	// 获取子节点
	public ClothingComponent getChild(int level) {
		return list.get(level);
	}

	

	public void print() {
		for(int i=0;i<level;i++) {
			System.out.print("--");
		}
		System.out.println(name);
		
		for(ClothingComponent clothing:list) {
			clothing.print();
		}
	}
	
}

//树叶
class  ClothingItem extends ClothingComponent{

	public ClothingItem(String name ,int level) {
		this.name=name;
		this.level=level;
	}
	@Override
	public void print() {
		// TODO Auto-generated method stub
		for(int i=0;i<level;i++) {
			System.out.print("--");
		}
		System.out.println(name);
	}
	
}

在这里插入图片描述

编写制作豆浆的程序，说明如下:
1. 制作豆浆的流程选材—>添加配料—>浸泡—>放到豆浆机打碎
2. 通过添加不同的配料，可以制作出不同口味的豆浆
3. 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
4. 请使用模板方法模式完成

package homework;


/*
 * 2.编写制作豆浆的程序，说明如下:
     1) 制作豆浆的流程 选材--->添加配料--->浸泡--->放到豆浆机打碎
     2) 通过添加不同的配料，可以制作出不同口味的豆浆
     3) 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
     4) 请使用 模板方法模式 完成 
 */
public class Client2 {
	public static void main(String[] args) {
		SoybeanMilk milk1=new Fivered_SoybeanMilk();
		milk1.TemplateMethod();
		System.out.println("");
		System.out.println("===========================================");
		System.out.println("");
		SoybeanMilk milk2=new Threeblack_SoybeanMilk();
		milk2.TemplateMethod();
		
	}

}
abstract class SoybeanMilk{
	
	//模板方法
	public void TemplateMethod() {
		select();
		add();
		dip();
		smach();
		getName();
	}
	
	//基本方法
	public void select() {
		System.out.println("选择材料");
	}
	public void dip() {
		System.out.println("开始浸泡");
	}
	public void smach() {
		System.out.println("用豆浆机打碎");
	}
	public abstract  void add();
	public abstract  void getName();
	
}
 class   Fivered_SoybeanMilk extends SoybeanMilk {

	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加材料：红枣+红豆+红皮花生+枸杞+红糖");
	}

	@Override
	public void getName() {
		// TODO Auto-generated method stub
		System.out.println("-----五红豆浆制作完成！-----");
	}
	 
 }

 class   Threeblack_SoybeanMilk extends SoybeanMilk {

		@Override
		public void add() {
			// TODO Auto-generated method stub
			System.out.println("添加材料：黑芝麻+黑豆+黑米++核桃花生");
		}

		@Override
		public void getName() {
			// TODO Auto-generated method stub
			System.out.println("-----三黑豆浆制作完成！-----");
		}
		 
	 }

在这里插入图片描述
本题还可以利用使用钩子方法对前面的模板方法进行改造

package homework;


/*
 * 我们还希望制作纯豆浆，不添加任何的配料，
 * 请使用钩子方法对前面的模板方法进行改造
 */
public class Client3 {
	public static void main(String[] args) {
		SoybeanMilk1 milk1=new purify_SoybeanMilk1();
		milk1.TemplateMethod();
		System.out.println("");
		
	}

}
abstract class SoybeanMilk1{
	
	//模板方法
	public void TemplateMethod() {
		select();
		if(hookMethod()){
			add();
		}
		dip();
		smach();
		getName();
	}
	
	//基本方法
	public void select() {
		System.out.println("选择材料");
	}
	public void dip() {
		System.out.println("开始浸泡");
	}
	public void smach() {
		System.out.println("用豆浆机打碎");
	}
	public boolean hookMethod(){
		return true;
	}
	public abstract  void add();
	public abstract  void getName();
	
}
 class   Fivered_SoybeanMilk1 extends SoybeanMilk1 {

	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加材料：红枣+红豆+红皮花生+枸杞+红糖");
	}

	@Override
	public void getName() {
		// TODO Auto-generated method stub
		System.out.println("-----五红豆浆制作完成！-----");
	}
	public boolean hookMethod(){
		return true;
	}
 }

 class   Threeblack_SoybeanMilk1 extends SoybeanMilk1 {

		@Override
		public void add() {
			// TODO Auto-generated method stub
			System.out.println("添加材料：黑芝麻+黑豆+黑米++核桃花生");
		}

		@Override
		public void getName() {
			// TODO Auto-generated method stub
			System.out.println("-----三黑豆浆制作完成！-----");
		}
		public boolean hookMethod(){
			return true;
		}
	 }
 class   purify_SoybeanMilk1 extends SoybeanMilk1 {

		@Override
		public void add() {
			// TODO Auto-generated method stub
			System.out.println("不添加任何材料");
		}

		@Override
		public void getName() {
			// TODO Auto-generated method stub
			System.out.println("-----纯豆浆制作完成！-----");
		}
		public boolean hookMethod(){
			return false;
		}
	 }

打印皮卡丘

package com.five;

public class Test {
		public static void main(String[] args) {
			System.out.println("  へ　　　　　／|");
			System.out.println(" /　│　　 ／　／");
			System.out.println("│　Z ＿,＜　／　　 /`ヽ");
			System.out.println(" │　　　　　ヽ　　 /　　〉");
			System.out.println(" Y　　　　　`　 /　　/");
			System.out.println(" ｲ●　､　●　　⊂⊃〈　　/");
			System.out.println("()　 へ　　　　|　＼〈");
			System.out.println(" >ｰ ､_　 ィ　 │ ／／");
			System.out.println(" ヽ_ﾉ　　(_／　 │／／");
			System.out.println(" 7　　　　　　　|／");
			System.out.println(" ＞―r￣￣`ｰ―＿)");
		}
}

假设有一个web托管公司，该公司在Windows和UNIX平台上托管服务。
该WEB托管公司在这两种平台上提供三种不同类型的托管包：基本、高级和更高级。
使用“抽象工厂”模式设计一个应用，查询该WEB托管公司提供的不同类型的托管包的功能

package com.abstractFactory;

/*
1.假设有一个web托管公司，该公司在Windows和UNIX平台上托管服务。
该WEB托管公司在这两种平台上提供三种不同类型的托管包：基本、高级和更高级。
使用“抽象工厂”模式设计一个应用，查询该WEB托管公司提供的不同类型的托管包的功能
*/
public class Client {
	public static void main(String[] args) {
		WebFactory window=new WindowFactory();
		
		//Window平台下的基本托管包
		BasicPackge W_Basic=window.creatBasicPackge();
		W_Basic.show();
		
		System.out.println();
		
		//Window平台下的高级托管包
		AdvancedPackage W_Advanced=window.creatAdvancedPackage();
		W_Advanced.show();
		
		System.out.println();
		
		//Window平台下的更高级托管包
		MoreAdvancedPackage W_MoreAdvanced=window.creatMoreAdvancedPackage();
		W_MoreAdvanced.show();

//
		System.out.println();
		WebFactory unix=new UNIXFactory();
		
		//UNIX平台下的基本托管包
		BasicPackge U_Basic=unix.creatBasicPackge();
		U_Basic.show();
		
		System.out.println();
		
		//UNIX平台下的高级托管包
		AdvancedPackage U_Advanced=unix.creatAdvancedPackage();
		U_Advanced.show();
		
		System.out.println();
		
		//Window平台下的更高级托管包
		MoreAdvancedPackage U_MoreAdvanced=unix.creatMoreAdvancedPackage();
		U_MoreAdvanced.show();
		
	}

}
//抽象工厂
interface WebFactory{
	public BasicPackge  creatBasicPackge();
	public AdvancedPackage  creatAdvancedPackage();
	public MoreAdvancedPackage  creatMoreAdvancedPackage();
}

//具体工厂1
class WindowFactory implements WebFactory{
	@Override
	public BasicPackge creatBasicPackge() {
		// TODO Auto-generated method stub
		System.out.println("某某人在本公司在Windows平台上办理了基本托管服务");
		return new W_BasicPackge();
	}
	@Override
	public AdvancedPackage creatAdvancedPackage() {
		// TODO Auto-generated method stub
		System.out.println("某某人在本公司在Windows平台上办理了高级托管服务");
		return new W_AdvancedPackage();
	}
	@Override
	public MoreAdvancedPackage creatMoreAdvancedPackage() {
		// TODO Auto-generated method stub
		System.out.println("某某人在本公司在Windows平台上办理了更高级托管服务");
		return new W_MoreAdvancedPackage();
	}
	
}

//具体工厂2
class UNIXFactory implements WebFactory{
	@Override
	public BasicPackge creatBasicPackge() {
		// TODO Auto-generated method stub
		System.out.println("某某人在本公司在UNIX平台上办理了基本托管服务");
		return new U_BasicPackge();
	}
	@Override
	public AdvancedPackage creatAdvancedPackage() {
		// TODO Auto-generated method stub
		System.out.println("某某人在本公司在UNIX平台上办理了高级托管服务");
		return new U_AdvancedPackage();
	}
	@Override
	public MoreAdvancedPackage creatMoreAdvancedPackage() {
		// TODO Auto-generated method stub
		System.out.println("某某人在本公司在UNIX平台上办理了更高级托管服务");
		return new U_MoreAdvancedPackage();
	}
	
}

//抽象产品1
interface BasicPackge{
	public void show();
}
//具体产品1
class W_BasicPackge implements BasicPackge{
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本公司在Windows平台上的基本托管包功能为：......");
	}
}

class U_BasicPackge implements BasicPackge{
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本公司在UNIX平台上的基本托管包功能为：......");
	}
}

//抽象产品2
interface AdvancedPackage {
	public void show();
}
//具体产品2
class W_AdvancedPackage implements AdvancedPackage {
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本公司在Windows平台上的高级托管包功能为：......");
	}
}

class U_AdvancedPackage implements AdvancedPackage {
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本公司在UNIX平台上的高级托管包功能为：......");
	}
}


//抽象产品3
interface MoreAdvancedPackage{
	public void show();
}

class W_MoreAdvancedPackage implements MoreAdvancedPackage{
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本公司在Windows平台上的更高级托管包功能为：......");
	}
}
class U_MoreAdvancedPackage implements MoreAdvancedPackage{
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本公司在UNIX平台上的更高级托管包功能为：......");
	}
}

在这里插入图片描述

KFC套餐
假如目前KFC里面有很多个套餐
在套餐里面有必点，也有选点
必点：汉堡（hamburger），薯条（chips）
选点：鸡腿（chicken），可乐（cola），披萨（pizza）
用建造者模式模拟两个套餐，套餐A与套餐B

package com.buider;


/*
 * 2.KFC套餐
    假如目前KFC里面有很多个套餐
    在套餐里面有必点，也有选点
	必点：汉堡（hamburger），薯条（chips）
	选点：鸡腿（chicken），可乐（cola），披萨（pizza）
	用建造者模式模拟两个套餐，套餐A与套餐B
 */
public class Client {
	public static void main(String[] args) {
		PackageType a=new A_Package();
		Director d1=new Director(a);
		SetMeal meal1=d1.gainPackage();
		meal1.show();
		System.out.println();
		PackageType b=new B_Package();
		Director d2=new Director(b);
		SetMeal meal2=d2.gainPackage();
		meal2.show();
	}

}

//产品:套餐
class SetMeal{
	private String hamburger;
	private String chips;
	private String chicken;
	private String cola;
	private String pizza;
	public String getHamburger() {
		return hamburger;
	}
	public void setHamburger(String hamburger) {
		this.hamburger = hamburger;
	}
	public String getChips() {
		return chips;
	}
	public void setChips(String chips) {
		this.chips = chips;
	}
	public String getChicken() {
		return chicken;
	}
	public void setChicken(String chicken) {
		this.chicken = chicken;
	}
	public String getCola() {
		return cola;
	}
	public void setCola(String cola) {
		this.cola = cola;
	}
	public String getPizza() {
		return pizza;
	}
	public void setPizza(String pizza) {
		this.pizza = pizza;
	}
	public void show() {
		System.out.println("本类套餐有：");
		System.out.println(this.hamburger+"\t"+this.chips+"\t"+this.chicken+"\t"+this.cola+"\t"+this.pizza+"\t");
//		System.out.println(this.chips);
//		System.out.println(this.chicken);
//		System.out.println(this.cola);
//		System.out.println(this.pizza);
	}
}

//抽象建造者:套餐类型
abstract class PackageType{
	//创建产品对象
	SetMeal setMeal=new SetMeal();
	public abstract void OrderHamburger();
	public abstract void OrderChips();
	public abstract void OrderCola();
	public abstract void OrderChicken();
	public abstract void OrderPizza();
	//返回产品对象
	public SetMeal getResult() {
		return setMeal;
	}
}

//具体建造者
class  A_Package extends PackageType{
	@Override
	public void OrderHamburger() {
		// TODO Auto-generated method stub
		setMeal.setHamburger("汉堡包");
	}
	@Override
	public void OrderChips() {
		// TODO Auto-generated method stub
    	setMeal.setChips("薯条");
	}
	public void OrderCola() {
		setMeal.setCola("可乐");
	}
	public void OrderChicken() {
		setMeal.setChicken("鸡腿");
	}
	public void OrderPizza() {
		setMeal.setPizza("披萨");
	}
}

class  B_Package extends PackageType{
	@Override
	public void OrderHamburger() {
		// TODO Auto-generated method stub
		setMeal.setHamburger("汉堡包");
	}
	@Override
	public void OrderChips() {
		// TODO Auto-generated method stub
    	setMeal.setChips("薯条");
	}
	public void OrderCola() {
		setMeal.setCola("可乐");
	}
	
	public void OrderPizza() {
		setMeal.setPizza("披萨");
	}
	@Override
	public void OrderChicken() {
		// TODO Auto-generated method stub
		
	}
}

//指挥者
class Director{
	private PackageType  packgeType;

	public Director(PackageType packgeType) {
		super();
		this.packgeType = packgeType;
	}
	
	public SetMeal gainPackage() {
		packgeType.OrderHamburger();
		packgeType.OrderChips();
		packgeType.OrderCola();
		packgeType.OrderChicken();
		packgeType.OrderPizza();
		return  packgeType.getResult();
	}
	
	
	
}

在这里插入图片描述

司机开车，有奔驰和宝马两种车。请用不满足依赖倒置原则和满足依赖倒置原则这两种方式编程实现。
依赖倒置

package com.week02;

/*
 * 司机开车，有奔驰和宝马两种车。请用不满足依赖倒置原则和满足依赖倒置原则这两种方式编程实现。
 */
//依赖倒置原则
public class Test3 {
	public static void main(String[] args) {
		Drive drive=new Drive();
		System.out.println("------司机开车-----");
		drive.moving(new Benz());
		drive.moving(new Bmw());
	}

}
interface Vehicle{
	public String move();
}
class Benz implements Vehicle{
	public String move() {
		return "该司机开的车是奔驰！";
	
	}
}
class Bmw implements Vehicle{
	public String move() {
		return "该司机开的车是宝马！";
	}
}
class Drive{
	public void moving(Vehicle vehicle) {
		System.out.println(vehicle.move());
	}
}

不满足依赖倒置原则

package com.week02;

/*
 * 司机开车，有奔驰和宝马两种车。请用不满足依赖倒置原则和满足依赖倒置原则这两种方式编程实现。
 */
//不满足依赖倒置原则
public class Test4 {
	public static void main(String[] args) {
		System.out.println("------司机开车-----");
		Benz1 benz=new Benz1();
		benz.move();
		System.out.println();
		Bmw1 bmw=new Bmw1();
		bmw.move();
	}
}
class Vehicle1 {
	public Vehicle1() {}
}
class Benz1 extends Vehicle1{
	public void move(){
		System.out.print("该司机开的车是奔驰！");
	}
}

class Bmw1 extends Vehicle1{
	public void move(){
		System.out.print("该司机开的车是宝马！");
	}
}

将学生类变成单例类

1.将构造器私有化
2.类的内部创建对象
3.提供一个静态的公共方法，返回该实例

package com_three;

public class Test01 {
	public static void main(String[] args) {
		LazySingleton instance1=LazySingleton.getInstance();
		LazySingleton instance2=LazySingleton.getInstance();
		System.out.println(instance1==instance2);
	}
}

/*
 * 将学生类变成单例类
 * 1.将构造器私有化
 * 2.类的内部创建对象
 * 3.提供一个静态的公共方法，返回该实例
 * 
 * 饿汉式
 * 类加载的时候单例对象就创建了
 * 
 * 缺点：类加载的时候实例就创建，容易造成内存浪费
 * 解决：懒汉式->延迟加载
 */
//懒汉式单例
class LazySingleton{
	private static volatile LazySingleton instance=null;
	private LazySingleton() {};
	public static LazySingleton  getInstance() {
		if(instance==null) {
			synchronized(LazySingleton.class) {
				if(instance==null) {
					instance =new LazySingleton();
				}
			}
			
		}
		return instance;
	}
}

package com_three;

public class Test02 {
	public static void main(String[] args) {
		HungrySingleton instance1=HungrySingleton.getInstance();
		HungrySingleton instance2=HungrySingleton.getInstance();
		System.out.println(instance1==instance2);
	}

}
  
  //饿汉式单例
class HungrySingleton{
	private static final HungrySingleton instance=new HungrySingleton();
	private HungrySingleton() {}
	public static HungrySingleton getInstance() {
		return instance;
	}
}

python语言题目

在终端中循环录入学生信息(名称,年龄,性别,成绩…)
如果名称为空，停止录入
1.在终端中打印所有学生信息(一行一个)
格式：xxx的年龄是xxx,性别是xxx,成绩是xxx
2.如果录入了”小明“，单独打印其成绩

name_dict = {}
while True:
    info_list = []
    name = input("请输入姓名：")
    if name == "":
        break
    else:
        age = int(input("请输入年龄："))
        info_list.append(age)
        sex = input("请输入性别(男/女)：")
        info_list.append(sex)
        score = float(input("请输入成绩："))
        info_list.append(score)
        name_dict[name] = info_list  # 也可以 = [age,sex,score]
for key in name_dict:
    print("%s的年龄是%d,性别是%s,成绩是%.1f" % (key, name_dict[key][0], name_dict[key][1], name_dict[key][2]))
if "小明" in name_dict:
    print(name_dict["小明"][2])

注册验证

user_name=input("请输入用户名(以“_”开头，3-30个字符)：")
password=input("请输入密码(由下划线、数字和字母共同组成，8-16个字符)：")
if  user_name.startswith( '_', 0, 1 )!='_':
    print('用户名请使用下划线开头')
elif 3>len(user_name) or 30<len(user_name):
    print('用户名长度超出限制')
elif 8>len(password) or 16<len(password):
    print('密码超出长度超出限制')
elif password.find('_')==-1:
    print('密码中未输入下划线')
else:
    password=password.replace('_','1')
    if password.isalnum():
        print("恭喜你完成注册!",'\n','用户名:',user_name,'\n','密码为：',password)
    else:
        print("密码中有其他字符，注册失败！")

“千年虫”是什么虫
需求：已知一个列表中存储的是员工的出生年份[88,89,90,98,00,99],由于时间比较外，出生的年份均为2位整数，现需要2位年份前加19，如果年份是00，将需要加上200
运行效果图：
[88,89,90,98,00,99]
[1988,1989,1990,1998,2000,1999]


year=[82,87,88,86,00,87,99,21]#源列表
print('源列表:',year)
for index,value in enumerate(year):
    print(index,value)
    if str(value)>'50':
        year[index]=int('19'+str(value))
    elif str(value)=='0':
        year[index] = int('200' + str(value))
    else:
        year[index] = int('20' + str(value))
print('------------------------')
print(year)
year.sort()
print('------------------------')
print('排序之后的列表：',year)

模拟京东购物流程
从键盘上输入5个商品信息（101 电脑）添加到商品列表中，展示商吕信息，提示用户选择商品，用户选中的商品添加到购物车中（购物车中的商品要逆序），用户选的商品不存在需要相应的提示。
运行效果图：
请输入商品编号和商品名称进行商品入库，第次只能输入一件商品 101 电脑
请输入商品编号和商品名称进行商品入库，第次只能输入一件商品 102 手机
请输入商品编号和商品名称进行商品入库，第次只能输入一件商品 103 耳机
请输入商品编号和商品名称进行商品入库，第次只能输入一件商品 104 优盘
请输入商品编号和商品名称进行商品入库，第次只能输入一件商品 105 电视
101 电脑
102 手机
103 耳机
104 优盘
105 电视
请输入要购买的商品的编号：101
商品已添加到购物车，请继续添加要购买的商品编号：
请输入要购买的商品的编号：102
商品已添加到购物车，请继续添加要购买的商品编号：
请输入要购买的商品的编号：106
该商品不存在！
请输入要购买的商品的编号：e
该商品不存在！
您购物车里已经选择商品为：
101 电脑
102 手机


things=[]

for i in range(5):
    goods=input('请输入商品编号和商品名称进行商品入库，每次只能输入一件商品:')
    things.append(goods)

print('商品仓库数据:')
for x in things:
    print(x)


shop_cart=[]
while True:
    flag=False
    num=input('请输入要购买的商品编号:\n')
    for x in things:
        if x.find(num) != -1:
            flag=True
            shop_cart.append(x)
            print('商品已经添加到购物车')
            break
    if not flag and num != "quit":
            print('该商品不存在！')
    if num=='quit':
            break


# shop_cart.reverse()
print('您购物车已经选择的商品：')
for y in shop_cart:
    print(y)

图片合成

'''

          下载到D盘
'''

import os
os.mkdir(r'D:/img')



url='http://www.netbian.com/mei/'
import requests

from lxml import etree

headers={
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36'
}
resp=requests.get(url,headers=headers)
resp.encoding='gbk'
# print(resp.text)

xp=etree.HTML(resp.text)

img_urls=xp.xpath('//ul/li/a/img/@src')
# print(img_urls)
img_names=xp.xpath('//ul/li/a/img/@alt')
# print(img_names)
for u,n in zip(img_urls,img_names):
    print(f'正在下载： 图片名：{n} 地址: {u}')
    img_resp=requests.get(u,headers=headers)
    with open(f'D:/img/{n}.jpg','wb+') as f:
        f.write(img_resp.content)
        f.close()

from PIL import Image

im=Image.open('D:/img/古风美女 长发 古装 河边 风景 桌面 壁纸.jpg')
w,h=im.size
# print(im.size)

image_row=4
image_column=4

import os
names= os.listdir('D:/img')
# print(names)
new_img=Image.new('RGB',(image_column*w,image_row*h))

for y in range(image_row):
    for x in range(image_column):
        o_img=Image.open('D:/img/'+names[image_column*y+x])
        new_img.paste(o_img,(x*w,y*h))

new_img.save('D:/new_img.jpg')

python图形化模拟界面

import tkinter as tk
window=tk.Tk()
window.title('模拟登陆')
window.geometry('600x400')

label1=tk.Label(window,text="用户名:",height=5,width=20,fg='black',font='微软雅黑 16')
label1.place(x=100,y=20,width=80,height=50)
entryCd1=tk.Entry(window,font='微软雅黑')
entryCd1.place(x = 185,y = 30 ,width = 200,height = 30)

label2=tk.Label(window,text="密码:",height=5,width=20,fg='black',font='微软雅黑 16')
label2.place(x=100,y=90,width=80,height=50)
entryCd2=tk.Entry(window,font='微软雅黑',show='*')
entryCd2.place(x = 185,y = 100 ,width = 200,height = 30)

def btnClicked():
    user = entryCd1.get()
    pwd = entryCd2.get()
    if user=='root' and pwd=='123':
        labelHello = tk.Label(window, text='登录成功', font='微软雅黑 22',fg='red')
        labelHello.place(x=123, y=200, width=250, height=30)
    else:
        labelHello1 = tk.Label(window, text='用户名或密码错误', font='微软雅黑  22',fg='red')
        labelHello1.place(x=123, y=200, width=250, height=30)

btnCal1=tk.Button(window,text='登录',font='微软雅黑',command=btnClicked)
btnCal1.place(x = 195,y = 150 ,width = 80,height = 30)

btnCal1=tk.Button(window,text='注册',font='微软雅黑')
btnCal1.place(x = 285,y = 150 ,width = 80,height = 30)


window.mainloop()

6.利用tkinter设计贷款计算器

import tkinter
import tkinter.messagebox

window=tkinter.Tk()
window.geometry('800x600')
window.title("贷款计算器")

menubar=tkinter.Menu(window)

def Hello():
    labelHello=tkinter.Label(window,text=' 班级:\n\n 学号:\n\n   姓名:\n\n',font='微软雅黑')
    labelHello.place(x = 560,y = 45 ,width = 200,height = 200)

def Message():
    tkinter.messagebox.showinfo("信息", " 班级:\n\n 学号:\n\n   姓名:\n\n")

menubar.add_command(label='退出',command=window.quit,font='微软雅黑 18')
menubar.add_command(label='提示',command=Hello,font='微软雅黑 18')
menubar.add_command(label='关于',command=Message,font='微软雅黑 18')

label1=tkinter.Label(window,text="贷款金额\t",height=5,width=20,fg='black',font='微软雅黑 14')
label1.place(x = 250,y = 45 ,width = 90,height = 50)
entryCd1=tkinter.Entry(window,font='微软雅黑')
entryCd1.place(x = 350,y = 50 ,width = 200,height = 30)

label2=tkinter.Label(window,text="贷款年限\t",height=5,width=20,fg='black',font='微软雅黑 14')
label2.place(x = 250,y = 95 ,width = 90,height = 50)
entryCd2=tkinter.Entry(window,font='微软雅黑')
entryCd2.place(x = 350,y = 100 ,width = 200,height = 30)

label3=tkinter.Label(window,text="贷款利率\t",height=5,width=20,fg='black',font='微软雅黑 14')
label3.place(x = 250,y = 135 ,width = 90,height = 50)
entryCd3=tkinter.Entry(window,font='微软雅黑')
entryCd3.place(x = 350,y = 140 ,width = 200,height = 30)

def btnClicked():
    money=float(entryCd1.get())
    year=float(entryCd2.get())
    monthrate=float(entryCd3.get())
    m=(money*monthrate)/(1-1/(1+monthrate)**(year*12))
    label4.config(text='每月还款:%.2f'%m)
    label5.config(text='总还款:%.2f'%(m*12*year))


btnCal=tkinter.Button(window,text='计算',font='微软雅黑',command=btnClicked)
btnCal.place(x = 350,y = 200 ,width = 200,height = 30)

label4=tkinter.Label(window,text="",height=5,width=20,fg='black',font=('Arial',18))
label4.place(x = 300,y = 255 ,width = 200,height = 100)
# entryCd4=tkinter.Entry(window)
# entryCd4.place(x = 350,y = 280 ,width = 200,height = 30)

label5=tkinter.Label(window,text="",height=5,width=20,fg='black',font=('Arial',18))
label5.place(x = 300,y = 320 ,width = 200,height = 100)
# entryCd5=tkinter.Entry(window)
# entryCd5.place(x = 350,y = 325 ,width = 200,height = 30)



frame=tkinter.Frame(window,width=50,height=50)
frame.pack()
frame.bind('<Button-1>',Hello)
window.config(menu=menubar)
window.mainloop()

class Calculator():
    money=1000
    time =3
    rate=0.045
    def __init__(self,money,time,rate):
        self.money = money
        self.time=time
        self.rate=rate

    def loan_total_money(self):
        return (self.money)*(self.loan_rate_money())

    def loan_rate_money(self):
        if self.time ==3:
            return 0.0603
        elif self.time == 5:
            return 0.06125000
        elif self.time == 20:
            return 0.0639

    def every_repayment_money(self):
        return (self.money + self.loan_total_money())/(self.time*12