Java面向对象三大特征--封装继承多态

封装
封装是面向对象的一个特征
在一个类中，将属性和过程 包装在方法中，封装的优点是属性具有安全性、重用性。

1. 属性的封装
   首先属性私有化（private修饰）
   提供获得属性、设置属性的方法，通常称为get/set方法，方法名已经形成了规范，boolean类型的属性，获得值方法的名字应该是isXxx

2. 过程的封装

//设置age属性值的方法 
//
public void setAge(int age){ 
	if(age>0&&age<2000) {
	 this.age = age; 
	 } }
	 //获得age属性的方法 
	 public int getAge(){ 
	 	return age; }
	 public void setMarry(
	 	boolean marry){ 
	 	this.marry = marry; 
	 	}
public boolean isMarry(){
	 return marry; }
 //既然自动分配无参的构造器，为什么还要自己定义构造器 
 Person(String name,char sex,int age,double height){ 
 //既有全局变量，又有局部变量，默认使用的是局部变量 
 this.name = name;
 this.sex = sex; 
 this.age = age; 
 this.height = height; 
 }
 Person(String name,char sex,int age){
  //既有全局变量，又有局部变量，默认使用的是局部变量 
  this.name = name; 
  this.sex = sex; 
  this.age = age; }

public class Tool {
 /*
 *
 * 判断某个字符是否是数字 
* @param c 
* @return 
*/
  public boolean isNumber(char c){
   if(c>='0'&&c<='9'){ 
   return true; }
   return false; }
    }

面向对象特征之 继承
子类继承了父类，子类就会拥有父类所有的属性和方法。在定义类时，通过extends关键字指定其父类。
继承 体现了类的复用，功能的扩充
java是单继承，一个子类只能继承一个父类，但一个父类可以有多个子类
继承可以是多层继承
Object类是所有类的根类，如果一个类没有继承任何类，默认继承Object类
访问范围修饰符
可以为属性、方法、类进行访问范围的修饰，决定在哪里可以调用他们。
本类 同包 子类 全局
private Y N N N
默认的 Y Y N N
protected Y Y Y N
public Y Y Y Y
讨论问题： private修饰的属性，子类能不能继承？
能继承，但是不能直接访问，可以通过get和set方法操作这个属性

方法的重写(Override)
子类继承了父类的方法不能满足子类的需求，在子类中对继承的方法进行重写。
重写语法：子类重写的方法，要求方法名、参数列表、返回类型与父类方法的一致，修饰范围不能低于父类方法的
修饰范围

//继承关系的定义 
public class Person extends Animal {
 //子类独有的属性 
 protected String tel; 
 //对继承的eat方法进行重写/改写 
 //返回类型、方法名、参数列表与父类方法相同 
 public void eat(){ 
 System.out.println("这个人吃的真香"); 
 }
 //不是重写的方法，是独有的方法 
 public void eat2(){
  System.out.println("这个人吃的真香");
}
//不是重写的方法，是独有的方法 
	public void eat(String s){ 
		System.out.println("这个人吃的真香"); }
	public void study(){ 
		System.out.println("人在学习"); 
		setName("tom"); 
		getName(); }
		 }

讨论： 为什么要重写？

1. 重写的方法和父类的方法名是相同的，父类定义的方法也是一种规范和约定。
2. 可以让自己写的代码 和 一些其他类的功能组合使用时，可以通过继承和重写来实现。
   重写和重载的区别

super关键字的使用
super代表父类，可以使用super调用父类的属性、方法、构造器。

1. super调用父类的属性

public class Person extends Animal {
 String name = "personName"; 
 public void show(){
   System.out.println(this.name); //personName  
   System.out.println(super.name); //animalName 
   
   }
    }

2. super调用父类的方法，如果子类重写了父类的方法，要调用父类的方法使用super实现

public class Person extends Animal { 
	String name = "personName"; 
	public void show(){ 
		this.eat(); //这个人吃饭真香 
		super.eat(); //这只动物正在进食 
		} }

3. super调用父类的构造器，继承的语法要求：在每个子类的构造器中一定要调用一次父类的构造器，默认调用的是父类无参的构造器

public class Animal{ 
	String name = "animalName"; 
	String color; 
	public Animal(String name, String color) { 		
		this.name = name; 
		this.color = color; } }

public class Person extends Animal { 
//子类独有的属性 
	protected String tel; 
	//创建Person对象，初始化三个属性值 
	public Person(String name,String color,String tel){ 
		super(name,color); 
		this.tel = tel; 
		} 
		}

super调用父类构造器，一定写在构造器的第一行

面向对象特征之 多态
一个事物有多种形态(称呼)，程序中的多态就是 用父类类型的引用 去引用子类的对象。

//多态写法 
Person p = new Student(); 
Animal a = new Student();

多态写法的优点：体现对象类型的灵活性，意味着一个对象可以有多种类型。

多态 调用方法

//多态写法 
Animal a = new Person(); 
//调用方法，调用的都是父类拥有的方法，而是子类对象执行这个方法 
a.eat(); 
//不能调用子类独有的方法 
a.study(); //错误

多态的写法：在编译期认为这个对象是父类对象（Animal对象），在运行期执行方法的对象是子类的对象(Person对象)

多态 调用子类对象独有的方法
进行向上转型，调用方法

//多态写法
 Animal a = new Person(); 
 //调用方法，调用的都是父类拥有的方法，而是子类对象执行这个方法 
 a.eat(); 
 //要调用子类独有的方法 
 Person p = (Person)a; 
 p.study();

在转型时，可能会出现ClassCastException异常
进行向下转型，否则出现异常
在转型时，为了避免ClassCastException的出现，使用instanceof运算符判断 对象是否时属于某个类型的。
对象 instanceof 类型 返回一个boolean结果

---

待更新：JVM内存分类，static关键字，游离块，静态游离块，设计模式（单例模式），final关键字