java基础知识：三大特性：封装、继承、多态以及方法重载、方法重写

1.封装：

1.1 定义：

对象属性隐藏在对象内部，外界无法直接操作和修改，如果外界要访问这个属性，则要提供公共方法进行访问。

1.2 如何实现封装

1. 属性用private修饰符修饰
   pirvate可以修饰成员变量和成员方法
   private修饰的属性和方法只有在当前类中才能访问，类以外的其他地方都不能访问

2. 提供getXXX和setXXX方法
   setXxx方法，是设置指定的xxx属性值用的
   getXxx方法，是获取指定的xxx属性值用的

代码演示：

public class Student{       
//使用private关键字来修饰属性，不允许外部直接访问该属性   
		private String name;        
//提供公共的setName方法，可以让外部调用该方法给name属性赋值    
		public void setName(String name){        
			this.name = name;   
				}     
//提供公共的getName方法，可以让外部调用该方法获取name属性的值  
		public String getName(){        
			return name;  
 	}    
}

1.3 封装的优点

1. 提高代码的安全性，重要信息可以私有化，不对外暴露

2. 提高代码的复用性，常用的代码或者功能封装到方法中，可以在其他地方反复调用

3. 封装代码的实现细节，便于修改内部代码，提高可维护性

4. 简化外部的调用，便于调用者使用

---

2.方法重载：

2.1 方法重载的要求如下

1、必须在同一个类中

2、方法的参数列表必须不同

参数列表：参数类型不同，参数个数不同，参数顺序不同

3、方法的修饰符，返回类型，抛出异常没有限制

4、方法名要一样

代码演示：

public class Test{        
	//参数的个数不同    
	public void test(){}   
	public void test(int a){}    
	public void test(String s1,String s2){}        
	//参数的类型不同    
	public void test(boolean flag){}    
	public void test(double salary){}        
	//参数的顺序不同    
	public void test(int a,String s){
	
	}    
	public void test(String s,int a){
	
	}        
	//方法的参数可以相同，也可以不同   
	public int test(int a,int b)
	{        
		return 0;   
	}
}    

2.2 重载特殊情况

public class Test{
   //方法重载    
	public void test(int a,long b){}   
 	public void test(long b,int a){}        
	public static void main(String[] args){        
		Test t = new Test();        
		t.test(1,1L);//调用到第一个方法        
		t.test(1L,1);//调用到第二个方法       
	    t.test(1,1);//问题：这个会调用到哪一个test方法？   
   } 
}

注意

这时候，t.test(1,1)代码是会编译报错的，因为类中定义的俩个方法都未匹配到
当参数无法完全精确匹配到方法的时候，参数会尝试做自动转换，然后再去尝试匹配方法

---

3.继承

定义

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么这些类（子类）就不需要再定义这些属性和行为，只要继承同一个类（父类），它们就可以直接访问父类中的非私有的属性和方法

继承的好处

1、提高代码复用性
2、类与类之间产生了关系，是多态特性的前提

继承关键字extents

注意
1、父类中的私有属性和方法，子类中不能访问。
2、父类中的构造器，子类是不能继承的
3、java中，类和类之间的继承是单继承：即一个类有且只能有一个父类，不能同时继承两个类
4、如果没有指定父类，则默认继承父类Object

---

4. 方法重写

如果子类和父类中出现了相同的方法，这种情况就叫做方法重写 (Override)。注意，方法重载是发生在同一个类中，方法重写发生在子父类之间

4.1 满足要求

1、方法名必须相同

2、参数列表必须相同

3、访问控制修饰符可以被扩大，但是不能被缩小

public > protected > default > private

4、方法抛出异常类型的范围可以被缩小，但是不能被扩大

例如：ClassNotFoundException --扩大–> Exception

5、返回类型可以相同，也可以不同

1、如果父类的返回类型是引用类型，子类重写后的方法返回类型可以和父类方法的返回类型保持一致，也可以是父类方法返回类型的子类型。

例如，父类方法的返回类型是Person，子类重写后的返回类可以是Person也可以是Person的子类型。

2、如果父类的返回类型是基本类型，那么子类重写后的返回类型必须和父类的保持一致。

例如: 父类方法的返回类型是int，子类重写后的返回类也必须是int

4.2 父类中哪些方法不能被重写：

1、父类中的静态方法不能被子类重写
2、父类中的私有方法不能被子类重写

注意

子类继承父类，在调用方法的时候，如果子类中没用重写，那么调用的是从父类继承的方法，如果子类重写了这个方法，那么将会调用到子类中重写后的方法

？？？问题？？？
问：
一般什么情况下，我们会在子类中，对从父类继承的方法进行重写？
答：
子类继承父类，继承了父类中的方法，但是父类中的方法并不一定能满足子类中的功能需要，所以子类中需要把方法进行重写。

---

5.多态

5.1 定义

相同类型的不同对象，调用同一个方法，最终执行结果是不同的

5.2 多态的前提

1、子类继承父类
2、子类重写父类中的方法
3、父类引用指向子类对象*

代码演示：

public class Person {    
	public void sayHello(){
        System.out.println("你好！");   
	}
}
class Student extends Person{    
	public void sayHello(){        
		System.out.println("hello！我是一名酷酷的学生");   
	}
}
class Teacher extends Person{
    public void sayHello(){        
		System.out.println("hi！我是一名酷酷的老师");  
	}
}

public static void main(String[] args) { 
   //声明父类的引用   
 	Person person;    
	int random = (int) (Math.random()*10); //Math.random获取0~9之间随机数  

//根据随机数的情况，让父类引用person指向不同的子类对象（Student对象或者Teacher对象）    
	if(random%2 == 0){       
         person = new Student();  
	} else  {
        person = new Teacher();   
    }    
}