Java常见代码结构
- 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<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]);
}
}
}