Java笔记(第十节 and 第十一节)

已于 2023-04-02 20:35:26 修改
阅读量276 收藏
点赞数 1
文章标签： java 开发语言
于 2023-04-02 00:23:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45368909/article/details/129873116
版权
文章介绍了对象之间的关联关系，包括一般关联、聚合和组合。关联可以是双向或单向，并在UML类图中通过箭头表示。多重性涉及一个对象可以与多少个其他对象关联，如一对一、一对多和多对多。文中通过Java代码示例展示了如何实现这些关系，并解释了为何在类内部关联对象时不需要`new`操作。此外，还提到了使用动态数组处理数量不确定的一对多和多对多关系。
摘要由CSDN通过智能技术生成

 本节内容：1:Associations 2:Multiplicity 3:实践

1：Associations:

定义:The formal name for a structural relationship that exists between classes is an association.

关联关系
关联（Association）关系是对象之间的一种引用关系，用于表示一类对象与另一类对象之间的联系，如老师和学生、师傅和徒弟、丈夫和妻子等。关联关系是类与类之间最常用的一种关系，分为一般关联关系、聚合关系和组合关系。我们先介绍一般关联。

关联可以是双向的，也可以是单向的。在 UML 类图中，双向的关联可以用带两个箭头或者没有箭头的实线来表示，单向的关联用带一个箭头的实线来表示，箭头从使用类指向被关联的类。也可以在关联线的两端标注角色名，代表两种不同的角色。

下图所示是老师和学生的关系图，每个老师可以教多个学生，每个学生也可向多个老师学，他们是双向关联。

在这里插入图片描述

2：Multiplicity 多重性

For a given association type X between classes A and B, the term multiplicity refers to the number of objects of type A that may be associated with a given instance of type B.

For example, a Student attends multiple Courses, but a Student has only one Professor in the role of advisor.

There are three basic “flavors” of multiplicity:

one-to-one

one-to-many

many-to-many

类图载入 -->自动生成代码window --> perspective -->open perspective -->plug in(插件)

3:下面我将会从一对一，多个一对一，一对多带你刨析内部逻辑。

小tip: 可以generate getters and setters 自动生成get和set函数

1对1:

为了可读性，我会将代码放到一个java文件中，实际应该将不同类放入不同java文件中 .

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Transcript tran = new Transcript();//创建对象
        Stu stu = new Stu();
        stu.setTran(tran);
        tran.setStu(stu);
        
        tran.print();//输出成绩
        stu.study();//学习一次
        tran.print();
    }
}
class Transcript
{
    private String ID;
    int score;
    private Stu student;//成绩单关联学生，且只有一位
    public void setStu(Stu student)
    {
        this.student = student;
    }
    public Stu getStu()//为什么是Stu? 将Stu理解为一种数据类型，返回值也为该数据类型即Stu
    {
        return student;
    }
    void print()//输出该成绩单所对应的学生的成绩
    {
        System.out.println(this.score);
    }
}
class Stu
{
    private String name;
    private Transcript tran;//学生关联成绩单，且只有一个
    public void setTran(Transcript tran)
    {
        this.tran = tran;
    }
    public Transcript getTran()
    {
        return tran;
    }
    void study()//学生学习
    {
        tran.score++;
    }
    
}
//为什么不new?

输出:  0

          1

为什么在类内进行关联时创建对象不需要new? 

private Stu student;

回归到根本，是要在主函数使用关联，然而如果在这new() ,同时在主函数new() ,在主函数中就是两段不同的内存。

也可以这么理解（个人理解）：将这种关联看成是一个属性而不是创建一个新的对象，相当于Transcript有一个属性是Student。

多个一对一（添加一个course)

 

只需要添加一个Cou类，其他类中添加get()和set()函数，主函数中做相似改动即可.

此处将score放入Course(Cou)类中

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Transcript tran = new Transcript();//创建对象
        Stu stu = new Stu();
        Cou cou = new Cou();
        
        stu.setTran(tran);//传入成绩单和课程
        stu.setCou(cou);
        
        tran.setStu(stu);
        tran.setCou(cou);
        
        cou.setStu(stu);
        cou.setTran(tran);
        
        cou.print();//输出成绩
        stu.study();//学习一次
        cou.print();
    }
}
class Transcript
{
    private String ID;
    private Stu student;//成绩单关联学生，且只有一位
    private Cou cou;
    public void setStu(Stu student)
    {
        this.student = student;
    }
    public Stu getStu()//为什么是Stu? 将Stu理解为一种数据类型，返回值也为该数据类型即Stu
    {
        return student;
    }
    public void setCou(Cou cou)
    {
        this.cou = cou;
    }
    public Cou getCou()
    {
        return cou;
    }
}
class Stu
{
    private String name;
    private Transcript tran;//学生关联成绩单，且只有一个
    private Cou cou;
    public void setTran(Transcript tran)
    {
        this.tran = tran;
    }
    public Transcript getTran()
    {
        return tran;
    }
    public void setCou(Cou cou)
    {
        this.cou = cou;
    }
    public Cou getCou()
    {
        return cou;
    }
    void study()//学生学习
    {
        cou.score++;
    }
    
}
class Cou
{
    int score;
    private Stu student;
    private Transcript tran;
    public void setTran(Transcript tran)
    {
        this.tran = tran;
    }
    public Transcript getTran()
    {
        return tran;
    }
    public void setStu(Stu student)
    {
        this.student = student;
    }
    public Stu getStu()
    {
        return student;
    }
    void print()//输出该成绩单所对应的学生的成绩
    {
        System.out.println(this.score);
    }
    
}

输出: 0 

         1

3:一对多(此处为2），多对多（此处为2），增加数组即可

public class Demo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Stu xh = new Stu("zxh");
		Stu xg = new Stu("zxg");
		
		Cou math = new Cou("Math");
		Cou eng = new Cou("Eng");
		
		Tran tranX = new Tran();
		Tran tranG = new Tran();
		
		xh.setTran(tranX);
		xh.enroll(new Cou("Eng"));
		xh.enroll(new Cou("Math"));
		xg.setTran(tranG);
		xg.enroll(new Cou("Eng"));
		xg.enroll(new Cou("Math"));
		
		math.addStu(xg);
		math.addStu(xh);
		math.setTran(tranG);
		math.setTran(tranX);
		
		eng.addStu(xg);
		eng.addStu(xh);
		eng.setTran(tranG);
		eng.setTran(tranX);
		
		tranG.setStu(xg);
		tranX.setStu(xh);
		
		System.out.println("before study:");
		xh.print();
		xh.study();
		System.out.println("after study:");
		xh.print();
		
		System.out.println("before study:");
		xg.print();
		xg.study();
		System.out.println("after study:");
		xg.print();
//xh 和 xg共用math的一段内存 改为stu.setCou(new Cou("Math"))（匿名对象）;但我不可能做两个数学课程，
		
	}
}

public class Cou 
{
	private int score;
	private int num;
	private String name;
	private Tran tran;
	private Stu stu[];
	
	public Cou() {
		super();
		stu = new Stu[2];
	}
	public Cou(String name) {
		super();
		this.name = name;
		stu = new Stu[2];
	}
	public Tran getTran() {
		return tran;
	}
	public void setTran(Tran tran) {
		this.tran = tran;
	}
	public Stu[] getStu() {
		return stu;
	}
	public void setStu(Stu[] stu) {
		this.stu = stu;
	}
	public void addStu(Stu temp)
	{
		stu[num++]=temp;
	}
	
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	
	public String getName() {
		return name;
	}
	public void print()
	{
		System.out.println(this.name+" : "+this.score);
	}
	
}
public class Stu
{
	private String name;
	private int num;
	private Tran tran;
	private Cou cou[];
//	private ArrayList<Cou> cou1;
	public Stu() {
		super();
		cou = new Cou[2];
//		cou1 = new ArrayList<>();
	}
	public Stu(String name) {
		super();
		this.name = name;
		cou = new Cou[2];
	}
	public Tran getTran() {
		return tran;
	}
	public void setTran(Tran tran) {
		this.tran = tran;
	}
	public Cou[] getCou() {
		return cou;
	}
	public void setCou(Cou[] cou) {
		this.cou = cou;
	}
	
	public void enroll(Cou temp)
	{
		cou[num++]=temp;
//		cou1.add(temp);
	}
	
	public void study()
	{
		for (int i = 0; i < cou.length; i++) {
			int temp = this.cou[i].getScore();
			this.cou[i].setScore(++temp);
		}
		
//		for (Iterator iterator = cou1.iterator(); iterator.hasNext();) {
//			Cou cou = (Cou) iterator.next();
//			int temp = cou.getScore();
//			cou.setScore(++temp);
//		}
//		for (Cou cou2 : cou) {
			int temp = cou3.getScore();
			cou.setScore(++temp);
//		}
	}
	public void study(String temp)
	{
		int i = 0;
		for (i = 0; i < cou.length; i++) {
			Cou tempC = this.cou[i];
			if (tempC.getName().equals(temp)) {
				int tempS = tempC.getScore();
				tempC.setScore(++tempS);
			}
		}
		if (i == cou.length) {
			System.out.println("you not");
		}
	}
	public void print()
	{
		System.out.println(this.name);
		for (int i = 0; i < cou.length; i++) {
			System.out.print("\t\t");
			this.cou[i].print();
			
		}
	}
//可以加一个计算平均成绩
//添加打印学生选了几门课
//添加学期类，学生添加课程可以选择学期

	
	
}

public class Tran 
{
	private Stu stu;
	private Cou cou[];
	public Tran() {
		super();
		cou = new Cou[2];
	}
	public Stu getStu() {
		return stu;
	}
	public void setStu(Stu stu) {
		this.stu = stu;
	}
	public Cou[] getCou() {
		return cou;
	}
	public void setCou(Cou[] cou) {
		this.cou = cou;
	}
	
	public void print()
	{
		System.out.println("东北大学成绩单");
		this.stu.print();
	}
}

小tip :匿名对象:

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        new A().q();
        
        //输出0，但是下面这段也输出0
        new A().i = 9;
        new A().q();
        
        //这是因为两个new(),指向的是不同的内存
        
    }
}
class A
{
    int i;
    void q()
    {
        System.out.println(i);
    }
}

输出 : 0

          0

4:一对多，多对多（数量不确定) ,将数组修改为动态数组

 

public class Demo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Stu xh = new Stu("zxh");
		Stu xg = new Stu("zxg");
		
		Cou math = new Cou("Math");
		Cou eng = new Cou("Eng");
		
		Tran tranX = new Tran();
		Tran tranG = new Tran();
		
		xh.setTran(tranX);
		xh.enroll(new Cou("Eng"));
		xh.enroll(new Cou("Math"));
		xg.setTran(tranG);
		xg.enroll(new Cou("Eng"));
		xg.enroll(new Cou("Math"));
		
		math.addStu(xg);
		math.addStu(xh);
		math.setTran(tranG);
		math.setTran(tranX);
		
		eng.addStu(xg);
		eng.addStu(xh);
		eng.setTran(tranG);
		eng.setTran(tranX);
		
		tranG.setStu(xg);
		tranX.setStu(xh);
		
		System.out.println("before study:");
		xh.print();
		xh.study();
		System.out.println("after study:");
		xh.print();
		
		System.out.println("before study:");
		xg.print();
		xg.study();
		System.out.println("after study:");
		xg.print();
		
	}
}

public class Stu
{
	private String name;
	private int num;
	private Tran tran;
//	private Cou cou[];
	private ArrayList<Cou> cou;
	public Stu() {
		super();
//		cou = new Cou[2];
		cou = new ArrayList<>();
	}
	public Stu(String name) {
		super();
		this.name = name;
		cou = new ArrayList<>();
	}
	public Tran getTran() {
		return tran;
	}
	public void setTran(Tran tran) {
		this.tran = tran;
	}
	public ArrayList<Cou> getCou() {
		return cou;
	}
	public void setCou(ArrayList<Cou> cou) {
		this.cou = cou;
	}
	
	public void enroll(Cou temp)
	{
//		cou[num++]=temp;
		cou.add(temp);
	}
	
	public void study()
	{
//		for (int i = 0; i < cou.length; i++) {
//			int temp = this.cou[i].getScore();
//			this.cou[i].setScore(++temp);
//		}
		//两种for循环形式都可，第一种方式
		for (Iterator iterator = cou.iterator(); iterator.hasNext();) 
		{
			Cou cou = (Cou) iterator.next();
			int temp = cou.getScore();
			cou.setScore(++temp);
		}
//		第二种方式
//		for (Cou cou2 : cou) {
			int temp = cou3.getScore();
			cou.setScore(++temp);
//		}
	}
	public void study(String temp)
	{
		boolean flg = false;
		for (Iterator iterator = cou.iterator(); iterator.hasNext();)
		{
			Cou cou2 = (Cou) iterator.next();
			if(cou2.getName().equals(temp))
			{
				flg = true;
				int tempx = cou2.getScore();
				cou2.setScore(++tempx);
			}
		}
		if(!flg )
		{
			System.out.println("查无此学科");
		}
	}
	public void print()
	{
		System.out.println(this.name);
		for (Iterator iterator = cou.iterator(); iterator.hasNext();) 
		{
			Cou cou2 = (Cou) iterator.next();
			cou2.print();//打印成绩
			
		}
	}
	
	
}
public class Cou 
{
	private int score;
	private int num;
	private String name;
	private Tran tran;
	private ArrayList<Stu> stu;
	
	public Cou() {
		super();
		stu = new ArrayList<>();
	}
	public Cou(String name) {
		super();
		this.name = name;
		stu = new ArrayList<>();
	}
	public Tran getTran() {
		return tran;
	}
	public void setTran(Tran tran) {
		this.tran = tran;
	}
	public ArrayList<Stu> getStu() {
		return stu;
	}
	public void setStu(ArrayList<Stu> stu) {
		this.stu = stu;
	}
	public void addStu(Stu temp)
	{
		stu.add(temp);
	}
	
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	
	public String getName() {
		return name;
	}
	public void print()
	{
		System.out.println(this.name+" : "+this.score);
	}
	
}

public class Tran 
{
	private Stu stu;
	private ArrayList<Cou> cou;
	public Tran() {
		super();
		cou = new ArrayList<>();
	}
	public Stu getStu() {
		return stu;
	}
	public void setStu(Stu stu) {
		this.stu = stu;
	}
	public ArrayList<Cou> getCou() {
		return cou;
	}
	public void setCou(ArrayList<Cou> cou) {
		this.cou = cou;
	}
	
	public void print()
	{
		System.out.println("东北大学成绩单");
		this.stu.print();
	}
}

tip:关于导入与导出 

导出 : File -> export

导入 : File -> import  ->Archive File / Exist Project -> 选择zip文件

kubeilly
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值