单向关联实现java代码 单向关联实现java代码运行
java中类与类之间的关系讲解
1.关联
创新互联建站坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站设计、成都做网站、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的资兴网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！
关联即对象与对象之间的连接。java类之间的关联是一个类的作为另一个的属性被定义，即“has-a”的关系。关联又分为组合与聚合两种。示例如下：
//两个类之间的聚合public class Car{}public class Person{
private Car car;
}//两个类之间的组合public class Car{}public class Person{
private Car car=new Car();//创建一个Car对象}123456789101112
关联又分为单向关联与双向关联，以上代码为单向关联(Person类关联Car类)，双向关联(Person类关联Car类，同时Car类关联Person类)代码如下：
public class Car{
private Person per;
}public class Person{
private Car car;
}123456
类之间的关联，可以一对一的关联，也可以一对多的关联。
2.依赖
依赖的具体表现是将一个类的对象当做方法参数传给另一个类的方法，是一种use-a的关系。如：
public class Person{
public void dirve(Car car){
}
}1234
关联与依赖的区别在于:关联是has-a的关系，依赖是use-a的关系;而且关联中Person关联Car，只要Person类对象存在，Car对象就存在;依赖中只有Person类对象调用到dirve()方法时，Car对象才会被创建，方法执行结束后，Car对象就被收回。
3.继承
类与类的另一个关系是继承。继承是一个类的定义基于另一个存在的类，即子类基于父类，如此可实现代码的重用，子类能够继承父类可访问的方法、属性，并能扩展新的能力，而且子类可重写父类方法以满足子类需要。在继承中子类可调用父类的构造方法，子类构造方法总是先调用父类的构造方法，而且默认情况下调用父类的无参构造方法，在子类构造方法的第一行使用super关键字即可调用父类构造方法。示例代码如下：
public class Point {
private double x; private double y; public double getX() { return x;
} public void setX(double x) { this.x = x;
} public double getY() { return y;
} public void setY(double y) { this.y = y;
} //无参构造方法
public Point() {
} //有参构造方法
public Point(double x, double y) { this.x = x; this.y = y;
} //draw（）方法
public void draw(){
}
}public class Circle extends Point {
private double r; public double getR() { return r;
} public void setR(double r) { this.r = r;
} //有参构造方法
public Circle(double x, double y) { super(x, y);
} public void draw() {
System.out.println("半径为：" + this.r + " x坐标为：" + getX() + " y坐标为：" + getY() + "的圆绘制成功！");
}
}public class Test {
public static void main(String[] args) {
Circle circle = new Circle(2, 3);
circle.setR(3);
circle.draw();
}
}
用Java语言实现单向链表
1.先定义一个节点类
package com.buren;
public class IntNode {
//定义一个节点类
int
info;
//定义属性，节点中的值
IntNode next;
//定义指向下一个节点的属性
public IntNode(int
i){ //构造一个next为空的节点
this(i,null);
}
public IntNode(int i,IntNode
n){ //构造值为i指向n的节点
info=i;
next=n;
}
}
2.再定义一个链表类，这是主要部分
package com.buren;
public class IntSLList {
private IntNode head,tail;
//定义指向头结点和尾结点的指针，
//如果大家看着这个不像指针的话，那就需要对指针有更深刻的了解
public
IntSLList(){
//定义一个空节点
head=tail=null;
}
public boolean
isEmpty(){
//判断节点是否为空
return
head==null;
//这行代码看起来似乎很神奇，其实真的很神奇，偶是服了
}
public void addToHead(int el){
//将el插入到头结点前
head=new
IntNode(el,head);
//将节点插入到头结点前，作为新的投节点
if(head==tail){
//给空链表插入节点时
tail=head;
//头结点和尾结点指向同一个节点
}
}
public void addToTail(int
el){
//向链表的尾部增加结点
if(!isEmpty()){
//判断链表是否为空
tail.next=new
IntNode(el);
//新建立一个值为el的节点，将链表的尾结点指向新节点
tail=tail.next;
//更新尾指针的指向
}else{
head=tail=new
IntNode(el);
//如果链表为空，新建立一个节点，将头尾指针同时指向这个节点
}
}
public int
deleteFromHead(){
//删除头结点，将节点信息返回
int
el=head.info;
//取出节点信息
if(head==tail){
//如果链表中只有一个节点
head=tail=null;
//删除这一个节点
}else{
head=head.next;
//如果链表中不止一个节点，将头结点的下一个节点作为头结点
}
return
el;
//返回原头结点的值
}
public int
deleteFromTail(){
//删除尾结点，返回尾结点的信息
int
el=tail.info;
//取出尾结点的值
if(head==tail){
// 如果链表中只有一个节点
head=tail=null;
//删除这个节点
}else{
IntNode
temp;
//定义中间变量
for(temp=head;temp.next!=tail;temp=temp.next);
//找出尾结点的前一个节点，注意最后的分号，
//这个for循环是没有循环体的，目的在于找出尾结点的前一个节点
//在整个程序中用了很多次这样的写法，相当经典啊
tail=temp;
//将找出来的节点作为尾结点，删除原来的尾结点
tail.next=null;
//将新尾结点的指向设为空
}
return
el;
//返回原尾结点的信息
}
public void
printAll(){
//打印链表中所有节点的信息
if(isEmpty()){
//如果链表为空
System.out.println("This
list is
empty!");
//输出提示信息
return;
//返回到调用的地方
}
if(head==tail){
//当链表中只有一个节点时
System.out.println(head.info);
//输出这个节点的信息，就是头结点的信息
return;
}
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null;temp=temp.next){
//遍历整个链表
System.out.print(temp.info+"
");
//输出每个节点的信息
}
System.out.println();
//输出一个换行，可以没有这一行
}
public boolean isInList(int
el){
//判断el是否存在于链表中
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null
temp.info!=el;temp=temp.next);
//将el找出来，注意最后的分
return
temp!=null;
// 如果存在返回true，否则返回flase，这两行代码很有思想
}
public void delete(int
el){
//删除链表中值为el的节点
if(head.info==el
head==tail){
//如果只有一个节点，并且节点的值为el
head=tail=null;
//删除这个节点
}else
if(head.info==el){
// 不止一个节点，而头结点的值就是el
head=head.next;
//删除头结点
}else{
IntNode
pred,temp;
//定义两个中间变量
for(pred=head,temp=head.next;temp.info!=el
temp.next!=null;pred=pred.next,temp=temp.next);
//跟上面的类似，自己琢磨吧，也是要注意最后的分号
pred.next=temp.next;
//将temp指向的节点删除，最好画一个链表的图，有助于理解
if(temp==tail){
//如果temp指向的节点是尾结点
tail=pred;
//将pred指向的节点设为尾结点，
}
}
}
//下面这个方法是在链表中值为el1的节点前面插入一个值为el2的节点，
//用类似的思想可以再写一个在链表中值为el1的节点后面插入一个值为el2的节点
public boolean insertToList(int el1,int
el2){
//定义一个插入节点的方法，插入成功返回true，否则返回false
IntNode
pred,temp; //定义两个中间变量
if(isEmpty()){
//判断链表是否为空
return
false;
//如果链表为空就直接返回false
}
if(head.info==el1
head==tail){
//如果链表中只有一个节点，并且这个节点的值是el1
head=new
IntNode(el2,head);
//新建立一个节点
return
true;
}else if(head.info==el1){
IntNode t=new
IntNode(el2);
t.next=head;
head=t;
return
true;
}else{
for(pred=head,temp=head.next;temp!=null
temp.info!=el1;pred=pred.next,temp=temp.next);
if(temp!=null){
IntNode
a=new IntNode(el2);
pred.next=a;
a.next=temp;
return
true;
}else{
System.out.println(el1+"
NOT EXEISTS!");
return
false;
}
}
}
3.下面是测试代码
public static void main(String[] args){
IntSLList test=new
IntSLList();
//test.addToHead(7);
test.addToTail(7);
System.out.println(test.insertToList(7,5));
test.printAll();
System.out.println(test.isInList(123));
}
}
单向的多对一关联在类中如何配置
在开始编码之前先分析一下hibernate中的单向多对一是种怎样的关联关系。
如图，一个团队里面会有多个成员，这里多方就是成员，一方就是这些成员所在的团队。如果配置了hibernate中的单向多对一关联，则意味着可以通过成员找到团队，但无法通过团队找到属于团队的成员。从数据库的角度看，假设有team表和member表，member表会有一个外键，参照的是team表的主键。
2
/12
接下来开始编码。
打开eclipse，创建一个java工程文件。
要想使用hibernate，如果不使用注解和其他框架的话，正常会先做三件事，
导入hibernate所需的jar包，编写hibernate.cfg.xml(配置文件)，还有一个就是编写一个Hibernate的工具类。
做完之后，工程目录、配置文件和工具类如图。
具体操作过程可参考：Hibernate5入门教程。
3
/12
接下来就是编写数据库表的实体类和对应的映射文件。
根据一开始说的例子，简单创建了类Team和类Member以及它们对应的映射文件，而且还创建了类Test用于测试。创建完后，完整的工程目录如图。
4
/12
类Team和类Member以及它们对应的映射文件如图。映射文件中配置多对一关联关系的代码为：many-to-one name="team" class="hibernate.many2one.Team" column="teamid"/many-to-one
5
/12
在配置文件中配置映射文件。注意要修改配置文件中的数据库名，用户名和密码。
6
/12
配置完后，在Test类中加入如图代码，测试是否配置正确。
7
/12
运行Test.java后，结果如图。Hibernate向数据库发送了三条sql语句，具体内容看图。
8
/12
进入mysql，查看配置的数据库(我的是bd_show)，查看bd_show中存在的表，如图可以看到刚刚hibernate生成的两个表。
9
/12
两个表的结构如图。
10
/12
向两个表中插入如图数据，用于等会的测试。
如果配置是正确的话，等会用hibernate去取成员的数据时，是能通过取出的成员数据得到他们所在的团队的数据。
11
/12
将Test类中main函数改为如图内容。
12
/12
修改后再次运行Test.java，控制台输出结果如图。可以看到，通过团队成员找到了成员所在的团队的名称。
jpa一对多的映射（单向），怎么更新
有两种方式实现一对多的单向关联。一种是在只使用@OneToMany来标识，这种方式是通过一张第三方表来保存关系。还有一种是使用@OneToMany和@JoinColumn来标注，这种方式是在多的一方(Book)的表中增加一个外键列来保存关系。
第一种方式，通过一张第三方表来实现一对多的单向关联：
Author.java如下，需要注意private SetBook books = new HashSetBook()的注解。只是使用了@OneToMany。
1 package com.cndatacom.jpa.entity; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 import javax.persistence.CascadeType; 7 import javax.persistence.Column; 8 import javax.persistence.Entity; 9 import javax.persistence.FetchType;10 import javax.persistence.GeneratedValue;11 import javax.persistence.Id;12 import javax.persistence.OneToMany;13 import javax.persistence.Table;14 15 16 /**17 * 作者18 * @author Luxh19 */20 21 @Entity22 @Table(name="author")23 public class Author {24 25 @Id26 @GeneratedValue27 private Long id;28 29 /**作者的名字*/30 @Column(length=32)31 private String name;32 33 /**作者写的书*/34 @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)//级联保存、更新、删除、刷新;延迟加载35 private SetBook books = new HashSetBook();36 37 38 39 public Long getId() {40 return id;41 }42 43 44 public void setId(Long id) {45 this.id = id;46 }47 48 49 public String getName() {50 return name;51 }52 53 54 public void setName(String name) {55 this.name = name;56 }57 58 59 public SetBook getBooks() {60 return books;61 }62 63 64 public void setBooks(SetBook books) {65 this.books = books;66 }67 68 69 70 71 }
Book.java如下，因为是单向的关联，所以这个实体不需要加任何的关联标识。
1 package com.cndatacom.jpa.entity; 2 3 import javax.persistence.Column; 4 import javax.persistence.Entity; 5 import javax.persistence.GeneratedValue; 6 import javax.persistence.Id; 7 import javax.persistence.Table; 8 9 /**10 * 书11 * @author Luxh12 */13 14 @Entity15 @Table(name="book")16 public class Book {17 18 @Id19 @GeneratedValue20 private Long id;21 22 /**书名*/23 @Column(length=32)24 private String name;25 26 public Long getId() {27 return id;28 }29 30 public void setId(Long id) {31 this.id = id;32 }33 34 public String getName() {35 return name;36 }37 38 public void setName(String name) {39 this.name = name;40 }41 42 43 }
只在Author实体中对private SetBook books = new HashSetBook()加上标注@OneToMany实现单向关联。这样就通过一个关联表来实现这种关联。生成数据库表如下,会以Author的表名和下划线和Book的表名生成一张表author_book来保存Author和Book的一对多单向映射。
在author_book表中，存的是Auhtor的id和Book的id:
第二种方式，通过在多方(Book)的表中增加一个外键列实现一对多的单向关联。
Author.java如下，需要注意private SetBook books = new HashSetBook()的注解。同时使用了@OneToMany和@JoinColumn。
1 package com.cndatacom.jpa.entity; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 import javax.persistence.CascadeType; 7 import javax.persistence.Column; 8 import javax.persistence.Entity; 9 import javax.persistence.FetchType;10 import javax.persistence.GeneratedValue;11 import javax.persistence.Id;12 import javax.persistence.JoinColumn;13 import javax.persistence.OneToMany;14 import javax.persistence.Table;15 16 17 /**18 * 作者19 * @author Luxh20 */21 22 @Entity23 @Table(name="author")24 public class Author {25 26 @Id27 @GeneratedValue28 private Long id;29 30 /**作者的名字*/31 @Column(length=32)32 private String name;33 34 /**作者写的书*/35 @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)//级联保存、更新、删除、刷新;延迟加载36 @JoinColumn(name="author_id")//在book表增加一个外键列来实现一对多的单向关联37 private SetBook books = new HashSetBook();38 39 40 41 public Long getId() {42 return id;43 }44 45 46 public void setId(Long id) {47 this.id = id;48 }49 50 51 public String getName() {52 return name;53 }54 55 56 public void setName(String name) {57 this.name = name;58 }59 60 61 public SetBook getBooks() {62 return books;63 }64 65 66 public void setBooks(SetBook books) {67 this.books = books;68 }69 70 71 72 73 }
Book.java不变。
在数据库中只生成了两张表：author和book。
再看book表的结构，会多了一列author_id。
当前文章：单向关联实现java代码 单向关联实现java代码运行
分享路径：http://myzitong.com/article/dopcidj.html