Java 封装、重载、重写

目录

• 封装
• 重载
• 方法重载与重写的区别
• 重写规则

封装

封装：隐藏类的属性和实现细节，对外提供公共的访问方式。
好处：
1） 程序更安全
2）访问器中可以灵活的使用流程控制语句
3）用户只能用我们提供的访问方式来访问。

class Person{
	// private :访问修饰符 只能在声明它的类中使用
	private int age;// 10
	// 间接访问 服务员
	// setter 访问器
	public void setAge(int age){// int age = 10
		// 18 - 65
		if(age >= 18 && age <= 65){
			this.age = age;// this.age = 10;
		}else{
			System.out.println("年龄必须是18-65之间");
			this.age = 0;// 赋值出错 默认值
		}
		
	}
	// 访问 getter访问器 
	public int getAge(){
		return age;// this.age
	}
	
}

public class TestPerson {

	public static void main(String[] args) {
		Person zhangsan = new Person();
		zhangsan.setAge(33); 
		System.out.println(zhangsan.getAge());

	}

}

重载

方法重载：
1） 同一个类中；
2） 方法名字相同；
3） 参数列表不同（个数，类型，顺序）
4） 与返回值无关
好处: 方便记忆。

public class TestOverload {
	public String f(){
		return "hello";
	}
	public void f(){
		System.out.println("hello");
	}
	public void f(byte n){
		System.out.println("byte");
	}
	public void f(short n){
		System.out.println("short");
	}
	public void f(int n ){
		System.out.println("int");
	}
	public void f(long n){
		System.out.println("long");
	}
	public void f(float n){
		System.out.println("float");
	}
	public void f(double n){
		System.out.println("double");
	}
	public void f(int n,double num){
		System.out.println("int_double");
	}
	public void f(double num,int n){
		System.out.println("double_int");
	}
	public void f(String ...arr){//可变参数列表，可以传入多个参数
		System.out.println("String...");
	}
	public void f(int ...arr){// int [] 可变参数列表，可以传入多个参数
		System.out.println("int...");
	}
	public void f(int [] arr){// int []
		System.out.println("int[]");
	}
	public static void main(String[] args) {
		TestOverload test = new TestOverload();
		test.f(11);// int
		test.f();
		test.f(11.1,22);
		test.f(11,22.2);
		test.f(11,22);// double ,int
		test.f(11);// int
		test.f((byte)22);// byte
		test.f(11.1);// double
		test.f(22.2f);// float
	}
}

方法重载与重写的区别

重写是建立在继承关系上，所谓方法的重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。
这样，就可以实现对父类方法的覆盖。如果子类将父类中的方法重写了，调用的时候肯定是调用被重写过的方法
如果要调用父类中的方法，可以通过使用super关键来实现，super关键字可以从子类访问父类中的内容，如果要访问被重写过的方法，使用“super.方法名(参数列表)”的形式调用。
如果要使用super关键字不一定非要在方法重写之后使用，也可以明确地表示某个方法是从父类中继承而来的。使用super只是更加明确的说，要从父类中查找，就不在子类查找了。

重写规则

在重写方法时，需要遵循以下的规则：

1. 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。
2. 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。
3. Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。
   父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，
   不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。
4. 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
   子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
5. 在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。同样的道理，如果子类中创建了一个成员变量，而该变量和父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此概念一般很少有人去研究它，因为意义不大。
6. 如果不能继承一个方法，则不能重写这个方法。