Java常见代码结构（简单Java类、关联数据库表、链表）

Java基础结构

这是Java基础的代码结构，包含：简单Java类、与数据表关联类、内外部类（链表）

1、简单Java类

简单Java类包括：属性、构造方法、setter和getter方法、功能方法
下面是简单Java类的例子：

public class Person {
	//属性
    private int id;
    private String name;
    
    //构造方法
    public Person(){}  // 构造的空参方法
    public Person(int nid, String nname){
        id = nid;
        name = nname;
    }
    
    //setter和getter方法
    public void setId(int n){
        id = n;
    }
    public void setName(String a){
        name = a;
    }
    public int getId(){
        return id;
    }
    public String getName(){
        return name;
    }
    
    //功能方法
    //输出到调用方法
    public  String getInfo(){
        return "雇员信息：" + "\n" + "雇员id：" + id + "\n" + "雇员姓名：" + name + "\n" ;
    }
}
public class Main{
	public static void main(String Args[]){
		Person per = new Person(001, "张三");
		System.out.println(per.getInfo());
	}
}

2、与数据表关联类

简要格式如下

类1{
 普通属性
  本类属性
  其他类属性
构造方法
类方法（get（包括其他类）、set包括其他类）、功能、输出）
}
类2{
 普通属性
  本类属性
  其他类属性
构造方法
类方法（get（包括其他类）、set包括其他类）、功能、输出）
}
主类{
  主方法{
      初始化对象1；
      初始化对象2；
      关联对象1；
      关联对象2；
   }
}

例子如下：
JAVA设置类之间的关联 => 类似数据库的表之间的关联
要求：
①一个人有一辆车，一辆车属于一个人
②一个人还有个孩子，孩子有一辆车，车属于孩子

class Member{
	private int mid;
	private String name;
	private Car car;		//自定义类Car ，未初始化，里面全是垃圾数据
	private Member child;//在类中定义一个该类的对象，未初始化
	
	public Member(int mid, String name){
		this.mid = mid;
		this.name = name;
	}
	public  String getMemberInfo(){
		return "人员编号：" + this.mid + "，姓名：" + this.name;
	}
	
	//可以查看修改其他类中的信息
	public void setCar(Car car){
		this.car = car;
	} 
	public Car getCar(){
		return this.car;
	}
	
	public void setChild(Member child){
		this.child = child;
	}
	
	public Member getChildInfo(){
		return this.child;
	}
}

class Car{
	private String title;
	private String color;
	private Member member;
	public Car(String title, String color){
		this.title = title;
		this.color = color;
	}
	public String getCarInfo(){
		return "汽车名字：" + this.title + "，颜色：" + this.color;
	}
	public void setMember(Member member){
		this.member = member;
	}
	public Member getMember(){
		return this.member;
	}
}

public class CarPerson{
	public static void main(String args[]){
		Member mem = new Member(40, "张三"); //新建人的对象
		Car car = new Car("BMW", "红色");    //新建车的对象
		mem.setCar(car); 									//一个人有一辆车
		car.setMember(mem); 								//一辆车属于一个人
		System.out.println(mem.getMemberInfo());            //输出：mem人信息
		System.out.println(mem.getCar().getCarInfo());      //输出：mem对应的车信息
		System.out.println("=======================");
		System.out.println(car.getMember().getMemberInfo());//输出：车对应人的信息
		System.out.println("=======================");
		
		Member chd = new Member(10, "小小");         //新建孩子对象
		Car ccar = new Car("aodi", "红色");          //新建车对象
		chd.setCar(ccar);						//孩子拥有车
		ccar.setMember(chd);					//车属于孩子
		mem.setChild(chd);
		
		System.out.println(mem.getChildInfo().getMemberInfo());      //人的孩子的信息
		System.out.println(mem.getChildInfo().getCar().getCarInfo());//人的孩子的车的信息
	}
}

3、内外部类

问：为什么要引用内外部类？

使用内外部类（链表）
外部类Node{
 普通属性
  本类属性
  其他类属性
构造方法
类方法（get（包括其他类）、set包括其他类）、功能、输出）
     内部类Link{
           普通属性
           本类属性
           其他类属性
           构造方法
           类方法（get（包括其他类）、set包括其他类）、功能、输出）
     }
}

内外部类（链表）如下：

class LinkNode{
//使用内部类最大的好处是可以和外部类进行私有操作的互相访问
		//内部类Node
		private class Node{
			private String data;
			private Node next;
			//构造方法
			public Node(String data){
				this.data = data;
		}
		
		//方法：增加节点
		public void addNode(Node newNode){
			if(this.next == null){
						//System.out.println("count = "+ count);
				this.next = newNode;
				    //count++;
			}else{
				this.next.addNode(newNode);
				
			}
		}
		//方法：输出
		public void print(){
			while(this.next != null){
				System.out.println("data = " + this.data);
			}
		}
		//方法：查询
		public boolean containsNode(String data){
			if(data.equals(this.data)){
				return true;
			}else{
				if(this.next != null){
					return this.next.containsNode(data);
				}else{
					return false;
				}
			}
		}
		//方法：删除非根节点
		//传入两个参数，一个是上一个节点，另一个是删除的数据
		public void removeNode(Node previous, String data){
			if(this.data.equals(data)){
				previous.next =this.next;
			}else{
				this.next.removeNode(this, data);
				//removeNode(this.next, data);
			}
		}
		//方法：将链表数据放到数组中输出，递归（代替指针）放入
		public void toArraryNode(){
			LinkNode.this.reData[LinkNode.this.foot ++] = this.data;
			if(this.next != null){
				this.next.toArraryNode();
			}
		}
	}
	
//外部类：LinkNode

	private Node root; //根节点，第一个元素
	private int count; //统计个数
	private int foot; //输出节点个数角标
	private String []reData; //输出节点数组
	
	//方法：增加一个节点
	public boolean  add(String data){
		if(data == null){
			return false;
		}
		Node newNode = new Node(data);
		if(this.root == null){
			this.root = newNode;
		}else{
			this.root.addNode(newNode);
		}
		this.count++;
		return true;
	}
	//方法：添加多个节点（方法重载）
	public boolean add(String []data){
		for(int x=0; x<data.length; x++){
			//添加不成功
			if(!this.add(data[x])){
				return false;
			}
		}
		//添加成功
		return true;
	}
	//方法：统计数据个数
	public int size(){
		return this.count;
	}
	//方法：判断是否空链表（1）
	public boolean isEmpty(){
		if(this.size() == 0){
			return true;
		}else{
			return false;
		}
	}
	//方法：判断是否空链表（2）???????????
	public boolean isEmpty2(){
		if(this.root == null){
			return true;
		}else{
			return false;
		}
	}
	//方法：查找数据
	public boolean contains(String data){
		//根节点没有数据，直接返回错误
		if(this.root == null || data == null){
			return false;
		}
		return this.root.containsNode(data); //交给node类处理
	}
	//方法：删除节点
	public void remove(String data){
		//数据不存在
		if(! this.contains(data)){
			return;
		}
		if(data.equals(this.root.data)){  //是根节点
			this.root = this.root.next;
		}else{                            //不是根节点
			this.root.next.removeNode(this.root, data);
		}
		this.count--;  //节点数量-1
	}
	//要把数据保存的数组
	public String []toArray(){
		if(this.count == 0){
			return null;
		}
		this.foot = 0; //清零
		this.reData = new String [this.count];
		this.root.toArraryNode();
		return this.reData;
	}
	
}
//主函数
public class Link{
	public static void main(String args[]){
		LinkNode all = new LinkNode();

		all.add("hello");    //添加结点
		all.add("world");    //添加结点
		all.remove("hello"); //删除节点
		
		System.out.println(all.contains("hello"));  //查找Hello节点
		System.out.println(all.size());             //输出节点个数
			
		System.out.println("========");
		String str[] = all.toArray();           //将节点转换成字符串输出
		for(int x=0; x<str.length; x++){
			System.out.println(str[x]);
		}
	}
}