JAVA基础

JAVA基础

类与类之间关系

面向对象程序设计中，我们通常将类之间的关系分为两大类型:1.横向关系 2.纵向关系

横向关系

1.依赖关系是一种比较紧密的关系，一般表现形式为一个方法的的执行，需要通过另一个对象的支持。

public class Job {

}
public class Worker {
	public void work(Job j){
}
	}  

2.关联关系是一种比依赖更为密切的关系，在代码层面的表现形式为，一个类的对象作为属性定义到另一个类中。

public clsass Student{
	int id;
	String name;
	Teacher teach;
}
//老师类
public class Teacher{
	Student []students;
}

3.聚合关系是一种比关联关系更为紧密的关系，表现是的两个类之间的一种包含，但是这个包含又不是必须或者不可分割的，从代码层面表现来看，跟关联是一致的，两者之间只是存在语义上的区别

//部门
public class Dept {
	int dno;
	String name;	
}

//员工
public class Emp {
	int eno;
	String name;
	double sal;
	Dept dept;
}

4.组合关系是以上横向关系中最强的关系，表现的是部分跟整体的关系，两者之间通常表现为不可分割的一种关系，但是代码层面的表现跟关联，聚合是一致的，只是一种语义的区别。

public class People {
	Head head;
	Body body;
	Foot foot;
}

public class Head{
    
}

public class Body{
    
}
public class Foot{
    
}

纵向关系

继承

继承（Extends）是面向对象语言的三大特征之一，体现出的是一种类的上下级关系，因此是一种纵向关系；

语法

[修饰符] class 子类名 父类名称{

​ //属性、方法的声明

}

父类

public class Father{
   private String firstName;
   private int house;
   private int car;
   private double money;
public String getFirstName() {
	return firstName;
}
public void setFirstName(String firstName) {
	this.firstName = firstName;
}
public int getHouse() {
	return house;
}
public void setHouse(int house) {
	this.house = house;
}
public int getCar() {
	return car;
}
public void setCar(int car) {
	this.car = car;
}
public double getMoney() {
	return money;
}
public void setMoney(double money) {
	this.money = money;
}

子类

public class Son extends Father{
    
}

访问控制

访问权限修饰符：在java中对于元素的访问提供了四种修饰符，分为为：private、default(不写)、protected、public；这四种修饰符分别对元素赋予了不同的访问权限，如图所示：

Object类

java.lang.Object是java中所有类的终极父类，即java中所有的类都从该类继承，Object中提供了很多常用的方法:

• toString()
• equals()
• hashCode()
• notify()
• notifyAll()
• wait()

多态之Overload(重载) & Override(重写)

方法的重写和重载都是面向对象程序中多态的一种实现策略。重载和重写都是发生在方法上；

方法重写

子类继承父类后，对父类中的某些方法覆盖，重新实现；在创建子类对象后再调用该方法时，此时使用的就是被重写之后的方法，而不是父类的方法

public class Animal{
    public void eat(){
        System.out.pritnln("吃东西");
    }
}

public class Cat extends Animal{
    
    /**方法重写*/
    @Override
    public void eat(){
        System.out.println("吃鱼");
    }
}

注意事项:

1. 方法的重写发生在继承关系的子类中，一般为子类重写父类的方法
2. 被重写的方法名称必须跟父类方法保持一致
3. 被重写的方法中参数的个数，顺序，类型必须跟父类方法一致，否则，该操作称之为重载而非重写
4. 被重写的方法返回值必须跟父类方法一致
5. 子类中重写的方法访问权限不能小于父类

== 和 equals

​ “"是一个比较运算符，一般用于基本类型数据的比较，比较的是两个基本类型的值是否一致，如果使用“”比较两个引用类型对象时，此时比较的是两个对象的内存地址，所以，在对引用类型数据比较时不要使用”==".

​ equals是来自于java.lang.Object类中的方法，默认实现采用的是“==”完成，但是其他类可以通过对Object继承并重写equals方法，来实现对象的比较，但是通常情况下重写equals就必须重写hashcode，确保两个对象除了数据信息一致外，在内存中的地址也必须是一致，才能完全相等.

一般IDE中自带对于equals和hashCode重写的功能

例如：

package stu;

public class Student {
	private String id;
	private String name;
	private String arg;
	private String address;
	 public Student() {
		// TODO Auto-generated constructor stub
	}
	public Student(String id, String name, String arg, String address) {
		super();
		this.id = id;
		this.name = name;
		this.arg = arg;
		this.address = address;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getArg() {
		return arg;
	}
	public void setArg(String arg) {
		this.arg = arg;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((address == null) ? 0 : address.hashCode());
		result = prime * result + ((arg == null) ? 0 : arg.hashCode());
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (address == null) {
			if (other.address != null)
				return false;
		} else if (!address.equals(other.address))
			return false;
		if (arg == null) {
			if (other.arg != null)
				return false;
		} else if (!arg.equals(other.arg))
			return false;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	 
    
}