目录

1 数组是引用数据类型

2 数组内存分析

3 可变参数

4 对象数组

5 类关联结构

6 自身关联结构

7 合同设计模式

8 数据表和简单java类

（1）一对一的关联映射

（2）一对多的关联映射

（3） 多对多的关联映射

2 数组内存分析

        同一块堆内存可以被多个栈内存所指向，而多个栈内存可以对同一个堆内容进行修改操作。

3 可变参数

        可以接收不定量的多个参数

public class demo01 {
    public static void main(String[] args) {
        demo01 demo01 = new demo01();
        demo01.not_one(1,2,3,4,5);
    }
    public void not_one(int... arr ){
        int sum = 0;
        for(int x :arr){
            System.out.print(x);
            sum+=x;
            System.out.println("t"+sum);
        }
    }
}

        计算器的例子：

class calc{
    public int fun(String a,int... arr){
        int ans=0;
        switch(a){
            case("+"):{
                for(int x:arr){
                    ans+=x;
                }
                break;
            }
            case("-"):{
                for(int i : arr){
                    ans-=i;
                }
                break;
            }
            case("*"):{
                ans = 1;
                for(int i:arr){
                    ans*=i;
                }
                break;
            }
            case("/"):{
                ans = 1;
                for(int i:arr){
                    ans/=i;
                }
                break;
            }
            default: return ans;
        }
        return ans;
    }
}

4 对象数组

        对象数组：数组分为基本数组和引用数组。以类对象为例，保存多个类对象就可以通过对象数组的形式来完成。

• 动态初始化：类名称【】 数组名=new 类名称【长度】
• 静态初始化：类名称【】 数组名=new 类名称【】 {对象实例，对象实例，对象实例。。。}

        所有动态初始化之后，它的元素都是null，因为引用数据类型的默认值都是null。

package Li.Array;
class book{
    private String name;
    private String suto;
    private double price;
    public book(String name,String suto,double price){
        this.name = name;
        this.suto = suto;
        this.price = price;
    }
    public String getInfo(){
        return "图书名称："+this.name+"t作者："+this.suto+"t价格："+this.price;
    }
}
public class demo02 {
    public static void main(String[] args) {
        book[] books = new book[3];//动态声明
        books[1] = new book("java入门","袁",123);
        System.out.println(books[1].getInfo());;

        book[] books1 = new book[]{new book("语文","teacher",100),new book("数学","teacher",90)};//静态声明
        System.out.println(books1[0].getInfo());
    }

        对象数组是将之前独立的若干个对象全部交由对象数组进行线性统一管理，数组对象本身属于嵌套引用的引用（数组中的元素也是引用类型，数组也是引用）。

5 类关联结构

一个人有一辆汽车或没有汽车。

 

        引用关联结构都是在程序中体现的，而最终程序想要真正的与现实生活对应，还需要有具体的对象。

package Li.Array;
//类关联
class Person{
    private String name;
    private int age;
    private car car;//
    Person(){}
    //声明构造方法时，尽量不要加入引用类型，在这里是不要加入car对象
    Person(String name,int age){
        this.name = name;
        this.age = age;
        this.car = null;
    }
    //引用对象 单独用set方法设置
    public void setCar(car car){
        this.car = car;
    }
    public String getCar(){
        return car.getName();
    }
    public String getName(){
        return this.name;
    }
    public String getInfo(){
        return "姓名："+this.name+"t年龄："+this.age;
    }

}
class car{
    private String name;
    private double price;
    private Person person;
    car(){}
    car(String name,double price){
        this.name = name;
        this.price = price;
    }
    //引用对象 单独用set方法设置
    public void setPerson(Person p){
        this.person = p;
    }
    public String getName(){
        return this.name;
    }
    public String getPerson(){
        return this.person.getName();
    }

}
public class demo03 {
    public static void main(String[] args) {
        car car = new car("宝马",100);
        Person xiaoming = new Person("小明",11);
        car.setPerson(xiaoming);
        xiaoming.setCar(car);
        System.out.println(car.getPerson());
        System.out.println(xiaoming.getCar());
        System.out.println(xiaoming.getInfo());
    }

}

6 自身关联结构

        自身关联自身，这种引用设计的操作结构可以被无限制方法，例如：在程序设计存在有数据结构的概念，而很多数据结构的实现的基本形式就是依据此种引用的关系完成。

package Li.Array;
//自身关联结构
class Person01 {
    private String name;
    private int age;
    private Person01 child; //引用自身
    private car01 car;
    public Person01(){}
    public Person01 (String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setChild(Person01 son){
        this.child = son;
    }
    public Person01 getChild(){
        return this.child;
    }
    public void setcar(car01 car){
        this.car = car;
    }
    public String getInfo(){
        return this.name+"t"+this.age;
    }
}
class car01{
    private String name;
    private double price;
}
public class demo04 {
    public static void main(String[] args) {
        Person01 father = new Person01("父亲",50);
        Person01 son = new Person01("儿子",15);
        father.setChild(son);
        System.out.println(father.getInfo());
        System.out.println(father.getChild().getInfo());
    }
}

7 合同设计模式

        合成模型模式（Composite）属于队形的结构模式，有时又叫做部分-整体模式（Part-Whole）。

• 合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
• 合成模式可以使客户端将单纯元素与复合元素同等看待。

 

题目：现在有一间教室，依据面向对象的设计思想进行抽象。

分析：在教室中有窗户，门，桌椅，黑板

//合成设计模式
class kezhuo { }
class men{ }
class windows{ }
class jiangzhuo{ }
//先把子类都设计好，然后进行组合
class jiaoshi{
    private kezhuo [] zhuo;//课桌有多个，所以是课桌对象组
    private men [] men;//前后门，所以是门 对象组
    private windows [] windows;//窗户有多个，所以是窗户 对象组
    private jiangzhuo jiangzhuo;//讲桌有一个，所以是讲桌对象
}

8 数据表和简单java类

        现代的程序开发基本上都是围绕数据库进行的开发，数据库需要承担业务处理之后的结果保存，于是数据库就成了数据保存的关键，在数据表设计的过程之中本身就是一种抽象的概念。

（1）一对一的关联映射

        通过对比可以发现，数据表和java类之间存在如下的关系：

1. 简单java类的名称=数据表的名称
2. 简单java类的属性和内容=数据表中数据列的名称和内容
3. 简单java类的一个实例化对象=数据表中的一条数据信息
4. 简单java类的多个实例化对象（对象数组）=数据表中的多行记录

 

（2）一对多的关联映射

        在掌握简单java类和数据表的对应关系后，可以扩展到一对多的关联映射。

（3） 多对多的关联映射

 实现步骤：

1 设置各自的实例化对象；

2 设置彼此之间的引用关联

3 依据引用结构获取相关的数据信息