Java基础结构
1、简单Java类2、与数据表关联类3、内外部类
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
