java面向对象编程（1）

面向对象编程（1） 基本思想 && 封装，继承，多态

面向对象编程与面向过程的基本思想

怎么把大象装入冰箱？

面向过程编程思想（POP）

1）打开冰箱
2）把大象装入冰箱
3）关上冰箱

面向对象 （OOP）

1)封装方法：
（打开冰箱）
（把大象装入冰箱）
（关上冰箱）
2）人{
（打开冰箱）
（把大象装入冰箱）
（关上冰箱）
}

封装

对一类事物，抽取它们共有的特性，然后封装成方法：
例如：

public class Encapsulation{
	public void open(){
		System.out.println("打开冰箱");
	}
	public void put(){
		System.out.println("大象放入冰箱");
	}
	public void close(){
		System.out.println("关上冰箱");
	}
}

把大象放入冰箱这一类事情，需要的方法封装起来，优点：
1）方便调用
2）减少代码量

继承

概述
现实生活中，有父亲和儿子，程序当中也是。程序是基于现实的，通过代码，来把现实中的事物换一种方式表达出来。

例如：
现实中的人

	public class People{
		private String name;
		private Integer age;
		//无参构造
		People(){
		}
		//有参构造
		People(String name,Integer){
			this.name=name;
			this.age=age;
		}
		public void setName(String name){
			this.name=name;
		}
		public String getName(){
			return name;
		}
		public void setAge(Integer age){
			this.age=age;
		}
		public Integer getAge(){
			return age;
		}
	}

现实生活中的学生,应该是人的一种，所有，可以继承People类

	public class Student extends People{
		private String sid;
		Student(){
			super();
		}
		Student(){
			super();
			
		}
		public void setSid(String sid){
			this.sid.sid;
		}
		public String getSid(){
			return sid;
		}
		
	}

总结

1. 在现实中，人是包含学生的，每一个人都有姓名和年龄，同样的，学生也是拥有自己的姓名和年龄，除此之外，每一个学生还拥有自己的学号（sid），这是People不具有的。

2. 当Student继承People之后，Student就拥有了People的方法以及属性，具体能访问那些属性或者方法，需要看对应的权限修饰符。而继承的可以的访问的部分，可以当作是自己的一部分。

3. this和super关键字
   

多态

概述

首先，要理解多态，应该清楚什么是编译类型？什么是运行类型？
1）编译类型：指程序在编译时，对象的类型，即对应的应该是声明类型
2）运行类型：指在运行过程中的类型，即对应的应该是真正构造的类型。
3)编译类型看左边，运行类型看右边
例如：

	People p=new Student();

编译类型：People
运行类型：Student

其次，应该知道什么是重写？不要和重载搞混
重写：即继承或者实现的类（也可以是子接口），对父类或者父接口的方法进行重写
重载：在一个类中，函数名一样，但是形参列表不一样
例如：

	public class People{
		/*
		...
		在上面写的基础上添加say()方法
		*/
		public void say(){
			System.out.println("people say");
		}
		
		//重载
		public void say(String str){
			System.out.println("people say"+str);
		}
	}
	
	public class Student extends People{
		//重写
		public void say(){
			System.out.println("student say");
		}	
	}

最后，就可以使用多态了

	public class TestPolymorphism{
		public static void main(String[] args){
			People p=new Student();
			//动态绑定，运行到这里,实际调用的是Student里面的say()
			p.say();
		}
	}

总结

多态作用
提高代码的通用性，常称作接口重用
多态的前提
1）有继承或者实现关系
2）有方法的重写
成员方法

1. 编译时：要查看引用变量所声明的类中是否有所调用的方法。
2. 运行时：调用实际new的对象所属的类中的重写方法。
   成员变量
   不具备多态性，只看引用变量所声明的类。

引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”