Codetest
题目1：xx服装企业订单生产与配送系统可行性分析报告
技术上，现有信息化、流程自动化技术成熟，可实现订单审核、采购、生产、配送流程的数字化，企业可通过内部人员与外部技术团队协作开发。经济上，系统开发和运营成本可控，能通过优化流程降低人力成本、提升订单处理效率增加收益，投资回报合理。管理上，企业部门职责明确，员工经培训可熟练操作，具备实施基础。综上，项目可行。
题目2：xx软件公司项目开发与交付系统可行性分析报告
技术上，软件项目管理、开发、测试等领域技术成熟，可实现项目计划、采购、开发、测试、交付流程的信息化管理，企业技术人员具备相应开发能力。经济上，系统可减少项目管理成本、提高开发效率，收益能覆盖开发和运营成本。管理上，企业各部门分工清晰，人员素质满足系统使用要求。因此，项目具备可行性。
题目3：xx展会观众信息管理系统可行性分析报告
技术上，数据库技术、刷卡识别技术成熟，可实现观众信息采集、刷卡记录、数据统计分析等功能，开发难度不大。经济上，系统开发成本较低，能通过提升展会管理效率、提供精准数据报表带来间接收益。管理上，工作人员易掌握系统操作流程，便于推广。综上，项目可行。
可行性分析从技术、经济、管理等维度展开，技术上均依托成熟的信息化技术，具备实施基础；经济上通过成本收益分析，验证了项目的合理性；管理上结合企业或组织的管理架构和人员素质，评估了系统推广的可行性。
// 策略接口
interface Strategy {
int calculate(int a, int b);
}
// 加法策略
class AddStrategy implements Strategy {
public int calculate(int a, int b) {
return a + b;
}
}
// 减法策略
class SubStrategy implements Strategy {
public int calculate(int a, int b) {
return a - b;
}
}
// 计算器类
class Calculator {
private Strategy strategy;
public Calculator(Strategy strategy) {
this.strategy = strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int a, int b) {
return strategy.calculate(a, b);
}
}
// 测试类
public class CalculatorTest {
public static void main(String[] args) {
// 创建加法计算器
Calculator addCalculator = new Calculator(new AddStrategy());
System.out.println("10 + 5 = " + addCalculator.executeStrategy(10, 5)); // 输出：15
// 创建减法计算器
Calculator subCalculator = new Calculator(new SubStrategy());
System.out.println("10 - 5 = " + subCalculator.executeStrategy(10, 5)); // 输出：5
// 更换策略
addCalculator.setStrategy(new SubStrategy());
System.out.println("10 - 5 = " + addCalculator.executeStrategy(10, 5)); // 输出：5
}
}
// 武器行为接口（抽象策略）
interface WeaponBehavior {
void useWeapon();
}
// 具体武器行为类（具体策略）
class SwordBehavior implements WeaponBehavior {
public void useWeapon() {
System.out.println("用宝剑攻击");
}
}
class KnifeBehavior implements WeaponBehavior {
public void useWeapon() {
System.out.println("用匕首攻击");
}
}
class BowAndArrowBehavior implements WeaponBehavior {
public void useWeapon() {
System.out.println("用弓箭攻击");
}
}
class AxeBehavior implements WeaponBehavior {
public void useWeapon() {
System.out.println("用斧头攻击");
}
}
// 角色类（环境类）
abstract class Character {
protected WeaponBehavior weapon;
public void setWeapon(WeaponBehavior w) {
this.weapon = w;
}
public abstract void fight();
}
// 具体角色类
class King extends Character {
public void fight() {
weapon.useWeapon();
}
}
class Queen extends Character {
public void fight() {
weapon.useWeapon();
}
}
class Knight extends Character {
public void fight() {
weapon.useWeapon();
}
}
class Troll extends Character {
public void fight() {
weapon.useWeapon();
}
}
// 测试类
public class StrategyPatternTest {
public static void main(String[] args) {
// 创建不同角色并设置武器
King king = new King();
Queen queen = new Queen();
Knight knight = new Knight();
Troll troll = new Troll();
// 为每个角色设置武器并战斗
king.setWeapon(new SwordBehavior());
king.fight(); // 输出：用宝剑攻击
queen.setWeapon(new BowAndArrowBehavior());
queen.fight(); // 输出：用弓箭攻击
knight.setWeapon(new AxeBehavior());
knight.fight(); // 输出：用斧头攻击
troll.setWeapon(new KnifeBehavior());
troll.fight(); // 输出：用匕首攻击
// 更换武器
king.setWeapon(new KnifeBehavior());
king.fight(); // 输出：用匕首攻击
}
}
// 定义一个互联网访问的接口
interface InternetAccess {
void connectToInternet(String website);
}
// 光猫类，实现互联网访问接口
class CatModem implements InternetAccess {
@Override
public void connectToInternet(String website) {
System.out.println("光猫连接到网站: " + website);
}
}
// 过滤路由器类，代理光猫，实现互联网访问接口
class FilteringRouter implements InternetAccess {
private CatModem catModem;
public FilteringRouter(CatModem catModem) {
this.catModem = catModem;
}
@Override
public void connectToInternet(String website) {
// 过滤不良网站
if (isAllowedWebsite(website)) {
catModem.connectToInternet(website);
} else {
System.out.println("访问被拒绝: " + website);
}
}
// 判断网站是否允许访问
private boolean isAllowedWebsite(String website) {
// 这里可以根据实际需求设置过滤规则
// 例如，过滤包含"adult"、"game"等关键词的网站
if (website.contains("bad") || website.contains("game")) {
return false;
}
return true;
}
}
// 测试类
public class ProxyPatternDemo {
public static void main(String[] args) {
// 创建光猫对象
CatModem catModem = new CatModem();
// 创建过滤路由器对象，传入光猫对象
FilteringRouter filteringRouter = new FilteringRouter(catModem);
// 测试访问不同网站
filteringRouter.connectToInternet("http://www.goodwebsite.com"); // 允许访问
filteringRouter.connectToInternet("http://www.badwebsite.com"); // 拒绝访问
filteringRouter.connectToInternet("http://www.gamewebsite.com"); // 拒绝访问
}
}
4
syms x y z
% 方程组 (1)
eq1_1 = log(x/y) == 9;
eq1_2 = exp(x + y) == 3;
solution1 = solve([eq1_1, eq1_2], [x, y]);
x1 = solution1.x;
y1 = solution1.y;
disp('方程组 (1) 的解为：');
disp(['x = ', char(x1)]);
disp(['y = ', char(y1)]);
% 方程组 (2)
eq2_1 = (4*x^2)/(4*x^2 + 1) == y;
eq2_2 = (4*y^2)/(4*y^2 + 1) == z;
eq2_3 = (4*z^2)/(4*z^2 + 1) == x;
solution2 = solve([eq2_1, eq2_2, eq2_3], [x, y, z]);
x2 = solution2.x;
y2 = solution2.y;
z2 = solution2.z;
disp('方程组 (2) 的解为：');
for i = 1:length(x2)
disp(['解 ', num2str(i), ':']);
disp(['x = ', char(x2(i))]);
disp(['y = ', char(y2(i))]);
disp(['z = ', char(z2(i))]);
end
6
syms beta1 beta2 x
% （1）化简 sin(beta1)*cos(beta2) - cos(beta1)*sin(beta2)
expr1 = sin(beta1)*cos(beta2) - cos(beta1)*sin(beta2);
simplified_expr1 = simplify(expr1);
disp('（1）化简结果为：');
disp(simplified_expr1);
% （2）化简 (4x^2 + 8x + 3)/(2x + 1)
expr2 = (4*x^2 + 8*x + 3)/(2*x + 1);
simplified_expr2 = simplify(expr2);
disp('（2）化简结果为：');
disp(simplified_expr2);
5
syms x y
% 定义符号常数 x 和 y
x = sym('6');
y = sym('5');
% 定义表达式 z
z = (x + 1) / (sqrt(3 + x) - sqrt(y));
% 计算 z 的值
result = vpa(z);
disp('z 的值为：');
disp(result);
4
syms x
% 定义函数 y
y = sin(x) - x^2 / 2;
% 求一阶导数 y'
y_prime = diff(y, x);
disp('一阶导数 y'' 为：');
disp(y_prime);
% 求二阶导数 y''
y_double_prime = diff(y, x, 2);
disp('二阶导数 y'''' 为：');
disp(y_double_prime);
3
syms x
% 定义函数 y
y = sin(x) - x^2 / 2;
% 求一阶导数 y'
y_prime = diff(y, x);
disp('一阶导数 y'' 为：');
disp(y_prime);
% 求二阶导数 y''
y_double_prime = diff(y, x, 2);
disp('二阶导数 y'''' 为：');
disp(y_double_prime);
2
syms x
% （1）lim (x→4) (x^2 -6x +8)/(x^2 -5x +4)
limit1 = limit((x^2 - 6*x + 8)/(x^2 -5*x + 4), x, 4);
disp('（1）极限为：');
disp(limit1);
% （2）lim (x→0⁻) |x|/x
limit2 = limit(abs(x)/x, x, 0, 'left');
disp('（2）极限为：');
disp(limit2);
syms x y z
% (1) 分解 x^9 - 1
f1 = factor(x^9 - 1);
disp('1) 分解结果为：');
disp(f1);
% (2) 分解 x^4 + x^3 + 2x^2 + x + 1
f2 = factor(x^4 + x^3 + 2*x^2 + x + 1);
disp('2) 分解结果为：');
disp(f2);
% (3) 分解 125x^6 + 75x^4 + 15x^2 + 1
f3 = factor(125*x^6 + 75*x^4 + 15*x^2 + 1);
disp('3) 分解结果为：');
disp(f3);
% (4) 分解 x^2 + y^2 + z^2 + 2(xy + yz + zx)
f4 = factor(x^2 + y^2 + z^2 + 2*(x*y + y*z + z*x));
disp('4) 分解结果为：');
disp(f4);
经过几次的培训，我对利川康养基础有了基本的了解。结合国家老龄化趋势、个人特长、利川地域优势，我想对资产、采购、教学管理、客房管理（我的意愿先后顺序）进行进一步了解和学习。
我的特长：
专科期间我担任2年记者团团长一职，负责多项事务，如
1、计算能力：我利用WPS Excel代码、函数统计社团成员工作量，由原来1人连续工作12小时（因为过于复杂此项目只能1人来操作，大概率还是算错），减少到1人只需要工作10分钟，在提高效率的同时保证数据99%准确。设计“微信公众号文章批量下载PDF”Python程序，由原来50人工作10分钟，减少到1人工作10分钟。本科期间又自学RPA程序自动化机器人，减少电脑重复操作的工作量。
2、总结能力：制作《社团工作文档》，如工作流程和要求、程序使用教程，减少社团成员学习和沟通成本。开展社团成员教学课程，了解课程的重点、难点，进行个性化实践教学。
3、观察力、洞察力：通过优化视觉设计、结构化排版、推文高度和文字温度，将 “宣传部年度总结” 推文阅读量从 2000 + 提升至 6700+，超越同期同类内容 200%。
4、全局观、大局意识：带来团队在50个社团中排名第一。创建社团图库，供平时推文的使用。
5、学习能力：独立运营自己的公众号，粉丝数为7000，日增20-50粉丝。目前自学AI智能体客服聊天，微信公众号24小时解决用户问题。
6、基本能力：学校官方微信公众号的运营，选题的统筹、策划、联络、推文编辑、海报制作、相机拍摄、视频制作等。
意愿理由：
1、结合自身发展需要，资产、采购可能和自己公众号的产品品牌运营具有相关性。
2、结合国家老龄化趋势，养老院、健康中国需要更多的人才，客房管理的管理流程、服务具有相关性。
3、因公众号需要，未来可能会发关于武汉周边地区的旅游攻略，利川的旅游、气温具有特色。
4、自然疗法、慢性病、正念冥想，每个人的正念习惯不一样，能不能用ai个性化定制，形成数据库。
结合以上内容，我想去观察、学习、成长。
// 颜色接口
interface Color {
String getColor();
}
// 具体颜色类：黄色
class Yellow implements Color {
@Override
public String getColor() {
return "黄色";
}
}
// 具体颜色类：红色
class Red implements Color {
@Override
public String getColor() {
return "红色";
}
}
// 包抽象类
abstract class Bag {
protected Color color;
public void setColor(Color color) {
this.color = color;
}
public abstract String getName();
public abstract String getColor();
}
// 具体包类：挎包
class HandBag extends Bag {
@Override
public String getName() {
return "挎包";
}
@Override
public String getColor() {
return color.getColor();
}
}
// 具体包类：钱包
class Wallet extends Bag {
@Override
public String getName() {
return "钱包";
}
@Override
public String getColor() {
return color.getColor();
}
}
// 客户端类
public class Client {
public static void main(String[] args) {
// 创建黄色挎包
Bag yellowHandBag = new HandBag();
yellowHandBag.setColor(new Yellow());
System.out.println(yellowHandBag.getName() + " - " + yellowHandBag.getColor());
// 创建红色钱包
Bag redWallet = new Wallet();
redWallet.setColor(new Red());
System.out.println(redWallet.getName() + " - " + redWallet.getColor());
}
}
package p11;
import java.util.*;
abstract class AbstractFile {
public abstract void add(AbstractFile c); //增加成员
public abstract void remove(AbstractFile c); //删除成员
public abstract AbstractFile getChild(int i); //获取成员
public abstract void killVirus(); //业务方法
}
//ImageFile：图像文件类，充当叶子构件类
class ImageFile extends AbstractFile {
private String name;
public ImageFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对图像文件'" + name + "'进行杀毒");
}
}
class TextFile extends AbstractFile {
private String name;
public TextFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对文本文件'" + name + "'进行杀毒");
}
}
class VideoFile extends AbstractFile {
private String name;
public VideoFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对视频文件'" + name + "'进行杀毒");
}
}
class Folder extends AbstractFile {
//定义集合fileList，用于存储AbstractFile类型的成员
private ArrayList<AbstractFile> fileList = new ArrayList<>();
private String name;
public Folder(String name) {
this.name = name;
}
public void add(AbstractFile file) {
fileList.add(file);
}
public void remove(AbstractFile file) {
fileList.remove(file);
}
public AbstractFile getChild(int i) {
return fileList.get(i);
}
public void killVirus() {
System.out.println("****对文件夹'" + name + "'进行杀毒");
//模拟杀毒，递归调用成员构件的killVirus()方法
for (AbstractFile obj : fileList) {
obj.killVirus();
}
}
}
public class T2 {
public static void main(String[] args) {
AbstractFile file1, file2, file3, file4, file5;
AbstractFile folder1, folder2, folder3, folder4;
folder1 = new Folder("Sunny的资料");
folder2 = new Folder("图像文件");
folder3 = new Folder("文本文件");
folder4 = new Folder("视频文件");
file1 = new ImageFile("小龙女.jpg");
file2 = new ImageFile("张无忌.gif");
file3 = new TextFile("九阴真经.txt");
file4 = new TextFile("葵花宝典.doc");
file5 = new VideoFile("笑傲江湖.rmvb");
folder2.add(file1);
folder2.add(file2);
folder3.add(file3);
folder3.add(file4);
folder4.add(file5);
folder1.add(folder2);
folder1.add(folder3);
folder1.add(folder4);
//从"Sunny的资料"文件夹开始进行杀毒操作
folder1.killVirus();
}
}
// 子系统类：Camera
class Camera {
public void turnOn() {
System.out.println("Camera turned on");
}
public void turnOff() {
System.out.println("Camera turned off");
}
}
// 子系统类：Light
class Light {
public void turnOn() {
System.out.println("Light turned on");
}
public void turnOff() {
System.out.println("Light turned off");
}
}
// 子系统类：Sensor
class Sensor {
public void turnOn() {
System.out.println("Sensor turned on");
}
public void turnOff() {
System.out.println("Sensor turned off");
}
}
// 子系统类：Alarm
class Alarm {
public void turnOn() {
System.out.println("Alarm turned on");
}
public void turnOff() {
System.out.println("Alarm turned off");
}
}
// 外观类：SecurityFacade
class SecurityFacade {
private Camera camera1, camera2;
private Light light1, light2, light3;
private Sensor sensor;
private Alarm alarm;
public SecurityFacade() {
camera1 = new Camera();
camera2 = new Camera();
light1 = new Light();
light2 = new Light();
light3 = new Light();
sensor = new Sensor();
alarm = new Alarm();
}
// 晚上高级别安全措施
public void turnOnHighSecurity() {
camera1.turnOn();
camera2.turnOn();
light1.turnOn();
light2.turnOn();
light3.turnOn();
sensor.turnOn();
alarm.turnOn();
}
public void turnOffHighSecurity() {
camera1.turnOff();
camera2.turnOff();
light1.turnOff();
light2.turnOff();
light3.turnOff();
sensor.turnOff();
alarm.turnOff();
}
// 白天低级别安全措施
public void turnOnLowSecurity() {
camera1.turnOn();
sensor.turnOn();
alarm.turnOn();
}
public void turnOffLowSecurity() {
camera1.turnOff();
sensor.turnOff();
alarm.turnOff();
}
}
// 客户端类：SecurityClient
public class SecurityClient {
public static void main(String[] args) {
SecurityFacade securityFacade = new SecurityFacade();
// 晚上开启高级别安全措施
securityFacade.turnOnHighSecurity();
// 白天切换到低级别安全措施
securityFacade.turnOffHighSecurity();
securityFacade.turnOnLowSecurity();
}
}
% 生成100个学生5门功课的成绩矩阵P（随机生成0-100之间的成绩）
P = randi([0, 100], 100, 5);
% 学生学号（假设学号为1到100）
studentIDs = 1:100;
% (1) 求每门课的最高分、最低分及相应学生学号
for i = 1:5
courseMax = max(P(:, i));
courseMin = min(P(:, i));
maxStudent = studentIDs(P(:, i) == courseMax);
minStudent = studentIDs(P(:, i) == courseMin);
fprintf('课程%d: 最高分=%.0f(学号=%d), 最低分=%.0f(学号=%d)\n', i, courseMax, maxStudent(1), courseMin, minStudent(1));
end
% (2) 求每门课的平均分和标准差
for i = 1:5
courseMean = mean(P(:, i));
courseStd = std(P(:, i));
fprintf('课程%d: 平均分=%.2f, 标准差=%.2f\n', i, courseMean, courseStd);
end
% (3) 求5门课总分的最高分、最低分及相应学生学号
totalScores = sum(P, 2);
totalMax = max(totalScores);
totalMin = min(totalScores);
totalMaxStudent = studentIDs(totalScores == totalMax);
totalMinStudent = studentIDs(totalScores == totalMin);
fprintf('总分: 最高分=%.0f(学号=%d), 最低分=%.0f(学号=%d)\n', totalMax, totalMaxStudent(1), totalMin, totalMinStudent(1));
% (4) 将5门课总分按从大到小顺序存入score中，相应学生学号存入num
[sortedScores, sortIndices] = sort(totalScores, 'descend');
score = sortedScores;
num = studentIDs(sortIndices);
fprintf('总分排序结果（前10名）:\n');
for i = 1:10
fprintf('学号=%d, 总分=%.0f\n', num(i), score(i));
end
4
% 生成30000个均匀分布的随机数
randomNumbers = rand(1, 30000);
% (1) 计算均值和标准差
meanValue = mean(randomNumbers);
stdValue = std(randomNumbers);
% (2) 查找最大元素和最小元素
maxValue = max(randomNumbers);
minValue = min(randomNumbers);
% (3) 计算大于0.5的随机数占比
ratio = sum(randomNumbers > 0.5) / 30000 * 100;
% 显示结果
fprintf('均值: %.4f\n', meanValue);
fprintf('标准差: %.4f\n', stdValue);
fprintf('最大元素: %.4f\n', maxValue);
fprintf('最小元素: %.4f\n', minValue);
fprintf('大于0.5的随机数占比: %.2f%%\n', ratio);
3
% 实验数据
X = [165, 123, 150, 123, 141];
Y = [187, 126, 172, 125, 148];
% 线性拟合
A = [X', ones(5, 1)];
coefficients = A \ Y';
% 提取系数
a = coefficients(1);
b = coefficients(2);
% 拟合直线
Y_fit = a * X + b;
% 计算相关系数
correlation_matrix = corrcoef(Y, Y_fit);
r = correlation_matrix(1, 2);
% 显示结果
fprintf('线性拟合曲线的方程为: y = %.4f x + %.4f\n', a, b);
fprintf('相关系数为: %.4f\n', r);
2
% 定义多项式
syms x;
p1 = 3*x + 2;
p2 = 5*x^2 - x + 2;
p3 = x^2 - 0.5;
% (1) 计算 p(x) = p1(x)*p2(x)*p3(x)
p = expand(p1 * p2 * p3); % 展开多项式
disp('p(x) = ');
disp(p);
% (2) 求 p(x)=0 的全部根
roots_p = solve(p == 0, x);
disp('p(x)=0 的全部根为：');
disp(roots_p);
% (3) 计算 x_i = 0.2*i (i=0,1,2,...,10) 各点上的 p(x_i)
x_vals = 0:0.2:2; % 生成 x_i 值
p_vals = subs(p, x, x_vals); % 计算 p(x_i)
disp('各点上的 p(x_i) 值为：');
disp(p_vals);
1
% 生成10x5的正态分布随机矩阵A
A = randn(10, 5);
% (1) 求A各列元素的均值和标准差
mean_vals = mean(A); % 各列均值
std_vals = std(A); % 各列标准差
% (2) 求A的最大元素和最小元素
max_val = max(A(:)); % 最大元素
min_val = min(A(:)); % 最小元素
% (3) 求A每行元素的和以及全部元素之和
row_sums = sum(A, 2); % 每行元素的和
total_sum = sum(A(:)); % 全部元素之和
% 或者使用 sum(row_sums) 或 sum(sum(A)) 来计算全部元素之和
% (4) 分别对A的每列元素按升序、每行元素按降序排序
% 对每列按升序排序
sorted_by_col = sort(A, 'ascend');
% 对每行按降序排序
sorted_by_row = sort(A, 2, 'descend');
// Point类
class Point implements Cloneable {
double x;
double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
@Override
protected Point clone() throws CloneNotSupportedException {
return (Point) super.clone();
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
}
// Circle类
class Circle implements Cloneable {
Point p;
double r;
public Circle(Point p, double r) {
this.p = p;
this.r = r;
}
// 浅克隆
@Override
protected Circle clone() throws CloneNotSupportedException {
return (Circle) super.clone();
}
// 深克隆方式1：手动克隆
public Circle deepClone1() throws CloneNotSupportedException {
Circle circle = (Circle) super.clone();
circle.p = (Point) p.clone();
return circle;
}
// 深克隆方式2：序列化
public Circle deepClone2() throws IOException, ClassNotFoundException {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(this);
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
return (Circle) objectInputStream.readObject();
}
@Override
public String toString() {
return "Circle{" +
"p=" + p +
", r=" + r +
'}';
}
}
// 测试类
public class PrototypePatternTest {
public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
// 创建原始圆
Circle originalCircle = new Circle(new Point(1.0, 2.0), 3.0);
System.out.println("原始圆: " + originalCircle);
// 浅克隆
Circle shallowClonedCircle = originalCircle.clone();
System.out.println("浅克隆圆: " + shallowClonedCircle);
System.out.println("原始圆的原点和浅克隆圆的原点是否相同: " + (originalCircle.p == shallowClonedCircle.p));
// 深克隆方式1
Circle deepClonedCircle1 = originalCircle.deepClone1();
System.out.println("深克隆圆1: " + deepClonedCircle1);
System.out.println("原始圆的原点和深克隆圆1的原点是否相同: " + (originalCircle.p == deepClonedCircle1.p));
// 深克隆方式2
Circle deepClonedCircle2 = originalCircle.deepClone2();
System.out.println("深克隆圆2: " + deepClonedCircle2);
System.out.println("原始圆的原点和深克隆圆2的原点是否相同: " + (originalCircle.p == deepClonedCircle2.p));
}
}
% 定义参数 s 和 t 的范围
s = linspace(0, pi/2, 50); % s 的范围是 0 到 pi/2
t = linspace(0, 3*pi/2, 50); % t 的范围是 0 到 3pi/2
% 创建网格
[S, T] = meshgrid(s, t);
% 计算 x, y, z 的值
x = cos(S) .* cos(T);
y = cos(S) .* sin(T);
z = sin(S);
% 绘制曲面图
figure
surf(x, y, z)
shading interp % 进行插值着色处理
grid on % 添加网格
xlabel('x')
ylabel('y')
zlabel('z')
title('曲面图形（插值着色处理）')
5
% 定义参数 s 和 t 的范围
s = linspace(0, pi/2, 50); % s 的范围是 0 到 pi/2
t = linspace(0, 3*pi/2, 50); % t 的范围是 0 到 3pi/2
% 创建网格
[S, T] = meshgrid(s, t);
% 计算 x, y, z 的值
x = cos(S) .* cos(T);
y = cos(S) .* sin(T);
z = sin(S);
> % 绘制曲面图
figure
surf(x, y, z)
shading interp % 进行插值着色处理
grid on % 添加网格
xlabel('x')
ylabel('y')
zlabel('z')
title('曲面图形（插值着色处理）')
% 定义参数 s 和 t 的范围
s = linspace(0, pi/2, 50); % s 的范围是 0 到 pi/2
t = linspace(0, 3*pi/2, 50); % t 的范围是 0 到 3pi/2
% 创建网格
[S, T] = meshgrid(s, t);
% 计算 x, y, z 的值
x = cos(S) .* cos(T);
y = cos(S) .* sin(T);
z = sin(S);
% 绘制曲面图
figure
surf(x, y, z)
shading interp % 进行插值着色处理
grid on % 添加网格
xlabel('x')
ylabel('y')
zlabel('z')
title('曲面图形（插值着色处理）')
5
% 定义 x 和 y 的范围
x = linspace(-5, 5, 21); % x 的 21 个值均匀分布在 [-5, 5]
y = linspace(0, 10, 31); % y 的 31 个值均匀分布在 [0, 10]
% 创建网格
[X, Y] = meshgrid(x, y);
% 计算 z 的值
Z = cos(X) .* cos(Y) .* exp(-(X.^2 + Y.^2) / 4);
% 创建图形窗口
figure
% 绘制曲面图
subplot(2, 1, 1)
surf(X, Y, Z)
grid on
xlabel('x')
ylabel('y')
zlabel('z')
title('曲面图')
% 绘制等高线图
subplot(2, 1, 2)
contour(X, Y, Z, 20) % 绘制 20 条等高线
grid on
xlabel('x')
ylabel('y')
title('等高线图')
4
% 定义 x 和 y 的范围
x = linspace(-5, 5, 21); % x 的 21 个值均匀分布在 [-5, 5]
y = linspace(0, 10, 31); % y 的 31 个值均匀``分布在 [0, 10]
% 创建网格
[X, Y] = meshgrid(x, y);
% 计算 z 的值
Z = cos(X) .* cos(Y) .* exp(-(X.^2 + Y.^2) / 4);
% 创建图形窗口
figure
% 绘制曲面图
subplot(2, 1, 1)
surf(X, Y, Z)
grid on
xlabel('x')
ylabel('y')
zlabel('z')
title('曲面图')
% 绘制等高线图
subplot(2, 1, 2)
contour(X, Y, Z, 20) % 绘制 20 条等高线
grid on
xlabel('x')
ylabel('y')
title('等高线图')
3
% 绘制三维曲线
t = linspace(0, 2*pi, 1000); % 定义 t 的范围
x = (2 + cos(t/2)) .* cos(t);
y = (2 + cos(t/2)) .* sin(t);
z = sin(t/2);
% 创建图形
figure
plot3(x, y, z, 'b', 'LineWidth', 1.5) % 绘制三维曲线
grid on % 添加网格
xlabel('X') % 设置 X 轴标签
ylabel('Y') % 设置 Y 轴标签
zlabel('Z') % 设置 Z 轴标签
title('三维曲线') % 设置图形标题
axis equal % 使坐标轴比例相等
% 绘制螺旋线
figure(1)
t = linspace(0, 20*pi, 1000);
x = cos(t);
y = sin(t);
z = t;
plot3(x, y, z, 'b', 'LineWidth', 1.5)
grid on
xlabel('X')
ylabel('Y')
zlabel('Z')
title('螺旋线')
axis equal
% 绘制环面
figure(2)
[u, v] = meshgrid(linspace(0, 2*pi, 100), linspace(0, 2*pi, 100));
x = (1 + cos(u)) .* cos(v);
y = (1 + cos(u)) .* sin(v);
z = sin(u);
surf(x, y, z)
grid on
xlabel('X')
ylabel('Y')
zlabel('Z')
title('环面')
axis equal
% 绘制半径为 10 的球面
figure(3)
[x, y, z] = sphere(100);
x = 10 * x;
y = 10 * y;
z = 10 * z;
surf(x, y, z)
grid on
xlabel('X')
ylabel('Y')
zlabel('Z')
title('半径为 10 的球面')
axis equal
% Step 1: 在编辑器栏内建立一个M文件
% 新建一个M文件，将以下代码复制进去运行即可
% 生成数据
x = linspace(0, 2*pi, 20); % 生成0到2π的20个等间距点
y = sin(x); % 计算正弦值
% 创建复数数据用于罗盘图和羽毛图
z = y + 1i * zeros(size(y)); % 罗盘图和羽毛图需要复数输入
% Step 2: 采用以上函数独立编制程序
figure; % 创建新图窗
% 子图1: 罗盘图
subplot(2, 2, 1); % 将图形窗口分割成2行2列，选择第1个子图
compass(z); % 绘制罗盘图
title('罗盘图'); % 添加标题
% 子图2: 羽毛图
subplot(2, 2, 2); % 选择第2个子图
feather(z); % 绘制羽毛图
title('羽毛图'); % 添加标题
% 子图3: 箭头图
subplot(2, 2, 3); % 选择第3个子图
quiver(x, zeros(size(x)), y, zeros(size(y))); % 绘制箭头图，显示正弦曲线的切线方向
title('箭头图'); % 添加标题
xlabel('x'); % X轴标签
ylabel('sin(x)'); % Y轴标签
% Step 3: 自主加上绘制辅助操作功能，对坐标等加以说明
% 在每个子图中已经添加了标题和坐标轴标签，使图形更清晰易读
% Step1: 建立一个m文件
% 新建一个M文件，将以下代码复制进去运行即可
% 成绩数据
score = [5, 17, 23, 9, 4]; % 优秀、良好、中等、及格、不及格的人数
% Step2: 写出绘制饼图的核心语句
explode = [1, 0, 0, 0, 0]; % 将“优秀”部分从饼图中分离出来
figure; % 创建新图窗
pie(score, explode); % 绘制饼图
% Step3: 设置图例位置和其他属性
legend({'优秀', '良好', '中等', '及格', '不及格'}, 'Location', 'eastoutside'); % 添加图例，位置为右边外侧
title('成绩统计分析'); % 添加标题
grid on; % 添加网格
```example
% step 1: 建立M文件
% 新建一个M文件，将以下代码复制进去运行即可
% step 2: 设置X轴的点数为101点
x = linspace(0, 2*pi, 101); % 生成0到2π的101个等间距点
% step 3: 建立核心算法
y = (0.5 + (3*sin(x))./(1 + x.^2)) .* cos(x); % 计算对应的y值
% step 4: 利用plot()独立编制程序
plot(x, y); % 绘制x和y的关系曲线
title('函数曲线 y = (0.5 + 3sinx/(1+x^2))cosx'); % 添加标题
xlabel('x'); % 添加X轴标签
ylabel('y'); % 添加Y轴标签
grid on; % 添加网格
// 定义Operation接口
interface Operation {
int operate(int a, int b);
}
// 实现Operation接口的Add类
class Add implements Operation {
@Override
public int operate(int a, int b) {
return a + b;
}
}
// 实现Operation接口的Subtract类
class Subtract implements Operation {
@Override
public int operate(int a, int b) {
return a - b;
}
}
// 计算器类
class Calculator {
private Operation operation;
public Calculator(Operation operation) {
this.operation = operation;
}
public int calculate(int a, int b) {
return operation.operate(a, b);
}
}
// 测试代码
public class Main {
public static void main(String[] args) {
Calculator calculator = new Calculator(new Add());
int result = calculator.calculate(5, 3);
System.out.println("Result: " + result); // 输出8
calculator = new Calculator(new Subtract());
result = calculator.calculate(5, 3);
System.out.println("Result: " + result); // 输出2
}
}
// 定义Animal接口
interface Animal {
void eat();
}
// 实现Animal接口的Cow类
class Cow implements Animal {
@Override
public void eat() {
System.out.println("Cow is eating grass.");
}
}
// 实现Animal接口的其他动物类
class Chicken implements Animal {
@Override
public void eat() {
System.out.println("Chicken is eating grain.");
}
}
// 定义Farm接口
interface Farm {
void feed(Animal animal);
}
// 实现Farm接口的BrightFarm类
class BrightFarm implements Farm {
@Override
public void feed(Animal animal) {
animal.eat();
}
}
// 测试代码
public class Main {
public static void main(String[] args) {
Farm farm = new BrightFarm();
Animal cow = new Cow();
Animal chicken = new Chicken();
farm.feed(cow); // 喂养牛
farm.feed(chicken); // 喂养鸡
}
}
// 定义Switch接口
interface Switch {
void open();
void close();
}
// 实现Switch接口的Light类
class Light implements Switch {
@Override
public void open() {
System.out.println("Light is on.");
}
@Override
public void close() {
System.out.println("Light is off.");
}
}
// 实现Switch接口的TV类
class TV implements Switch {
@Override
public void open() {
System.out.println("TV is on.");
}
@Override
public void close() {
System.out.println("TV is off.");
}
}
// Room类
class Room {
private Switch livingSwitch;
public Room() {
this.livingSwitch = null;
}
public void enter() {
if (livingSwitch != null) {
livingSwitch.open();
}
}
public void leave() {
if (livingSwitch != null) {
livingSwitch.close();
}
}
public void setLivingSwitch(Switch switcher) {
this.livingSwitch = switcher;
}
}
// 测试代码
public class Main {
public static void main(String[] args) {
Room room = new Room();
Light light = new Light();
TV tv = new TV();
room.setLivingSwitch(light);
room.enter(); // 打开灯
room.leave(); // 关闭灯
room.setLivingSwitch(tv);
room.enter(); // 打开电视
room.leave(); // 关闭电视
}
}
浙公网安备 33010602011771号