正文
java类关系代码实现 java类的五种关系
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java中如何在一个类中声明包含另一个类
java中一个类包含另一个类大致可以有两种实现方式，①使用has a这种方式来持有另外一个类的对象的引用，②也可以使用内部类来实现包含另一个类.
内部类代码实现，如下：pre t="code" l="java"public class A{
pvivate static B b;
private static class B{
//这只是用静态内部类来实现.
}
}has a代表的是对象和它的成员的从属关系。可以分为组合与聚合两种。/ol 组合：表示两个对象是整体与部分的关系为强关系 聚合：表示两个对象是整体与部分的关系为弱关系 4.has a代码如下：pre t="code" l="java" public class A {
// 这样就能持有另一个类的引用，两者间的关系为弱关系
public class B b;
}
public class A{
//这样就能持有另一个类的引用，两者间的关系为强关系，因为是私有的
private class B b;
}
相关问答
Q1: Java 类中类 是怎么实现的？
是叫Inner Class啦。
和变量差不多。随便在类中什么地方写。也和变量一样有作用域。在函数内部写的类java类关系代码实现，在函数外就不可调用java类关系代码实现了。
public class A {
private class B {}
public static void main(String[] args) {
new A().new B();
}
}
这样的内部类中不能含有任何static成员。你也看到了，要生成B的实例必须建立在A实例的基础上。因为每个内部类都必须拥有一个指向外部类的指针。这样才能访问外部类的变量，private的也行。
把内部类声明为static，那么就不会有一个指向外部类的指针。自然也访问不了外部类的变量，除非外部变量是static的。也自然不需要先生成外部类的实例才能生成内部类的实例。这样的内部类叫做Nested Class
Thinking in Java里讲的很清楚了。自己去看看吧。
Q2: 求解：Java中类和类之间的三种关系用代码举例
//依赖最常见的是参数关系，如：
public class B{
/***B中的一个方法**/
public void testMethod(A a){
//此时B和A是依赖关系
}
}
//聚合关系通常表现为部分与整体的关系，如：
public class B{
/***B中的一个属性**/
A a;
}
//泛化关系通常表现为继承关系，如：
public class B extends A{
}
Q3: java 类与类之间的关系 及uml图
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();
}
}
Q4: JAVA:编写一个动物的继承关系代码.
下面是一个简单的 Java 程序示例，用于实现山羊和狼的继承关系，并在测试类中进行验证：
Animal.java:
```java
public abstract class Animal {
public void walk() {
System.out.println("走路");
}
public abstract void eat();
}
```
Goat.java:
```java
public class Goat extends Animal {
@Override
public void eat() {
System.out.println("吃草");
}
}
```
Wolf.java:
```java
public class Wolf extends Animal {
@Override
public void eat() {
System.out.println("吃肉");
}
}
```
AnimalTest.java:
```java
public class AnimalTest {
public static void main(String[] args) {
Goat goat = new Goat();
wolf wolf = new wolf();
goat.eat(); // 输出：吃草
wolf.eat(); // 输出：吃肉
goat.walk(); // 输出：走路
wolf.walk(); // 输出：走路
}
}
```
在此程序中，我们定义了一个 `Animal` 类作为基类，包含了所有动物都会有的行为（例如走路），并使用抽象方法 `eat()` 表示不同动物的饮食习惯。然后通过继承实现 `Goat` 和 `Wolf` 两个子类，并分别重写 `eat()` 方法。
在测试类中，我们分别创建了一个 `Goat` 和一个 `Wolf` 对象，并分别调用其 `eat()` 和 `walk()` 方法进行验证。可以看到，不同的动物具备不同的饮食习惯，但它们的走路行为是一致的。
Q5: 用纯Java类实现学生和老师的多对多关系
import java.util.List;
public class Student {
private int id;
private String name;
private ListClass classids;
public Student(int id,String name,ListClass class_id){
this.id = id;
this.name = name;
this.classids=class_id;
}
}
public class Teacher {
private int id;
private String name;
public Teacher(int id,String name){
this.id = id;
this.name = name;
}
}
public class Class {
private int id;
private String name;
private Teacher teacher_id;
public Class(int id,String name,Teacher teacher_id ){
this.id = id;
this.name = name;
this.teacher_id=teacher_id;
}
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Teacher t1=new Teacher(11,"瑶瑶老师");
Teacher t2=new Teacher(22,"甜甜老师");
Teacher t3=new Teacher(33,"笨笨老师");
Class c1=new Class(1,"语文",t1); //课程和老师的关联 1:1
Class c2=new Class(2,"数学",t2);
Class c3=new Class(3,"英语",t3);
ListClass list1=new ArrayListClass();
list1.add(c1);
list1.add(c2);
ListClass list2=new ArrayListClass();
list2.add(c1);
list2.add(c3);
Student s1=new Student(001,"张三",list1); //学生和课程的关联 1：m
Student s2=new Student(002,"李四",list2);
}
}
这样就得出了学生和老师的关联 是m:n
关于java类关系代码实现和java类的五种关系的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
