标签：
面向对象三大特性 封装，继承和多态
封装
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面(方法)。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术。
封装是分为两部分：属性的封装，方法的封装。封装起来就是为了对外隐藏。
类本身和方法本身就是一种封装，体现的是装配的含义。
在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
属性的封装通过private，同时还要提供可以访问该私有属性的方法。
这个方法就要写在类里面。
Java里面对私有属性提供了两个方法：setter和getter，而且这两个方法必须是public。
package yantai;
import java.util.Scanner;
public class Account {
private double balance=100;
private String cardNo;
public double getBalance() {
///
Scanner s=new Scanner(System.in);
System.out.println("请输入密码");
String passwd = s.next();
if(!passwd.equals("ok")){
System.out.println("输入密码不正确....");
throw new RuntimeException();
}
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
/**
* 存款
*/
public void deposit(int money){
this.balance=this.balance+money;
System.out.println("存了："+money);
System.out.println("目前卡余额："+this.balance);
}
/**
* 取款
*/
public void withdraw(int money){
this.balance=this.balance-money;
System.out.println("取了："+money);
System.out.println("目前卡余额："+this.balance);
}
public static void main(String[] args) {
//先创建一个对象，对象名字叫小明
Account a = new Account();
System.out.println(a.balance+"-----------");
a.deposit(100);
a.withdraw(200);
}
}
继承
使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，同时也拥有了父类的功能，使得复用以前的代码非常容易，减少重复代码的编写。能够大大缩短开发周期
父类：（超类）被继承
子类：（派生类）继承父类，并有自己新的特性。
什么时候适合设计成类之间的继承关系？
为了重复利用代码
这两个类之间有一种is a关系
子类对象构建过程：
定义子类对象时：
分配空间 （父类对象空间，子类对象空间）
递归构造父类对象
初始化属性
调用构造方法：先调用父类的构造方法再调用子类的构造方法
子类可以把父类的什么修饰符修饰的属性和方法继承过来。Public,protected,default(父类和子类在同一个包)。
访问修饰符
一共是四种：public ,protected—为了继承,default,private
子类：派生类
父类：超类
方法的重载（Overload）
涉及到一个类，要求这些方法的方法名一样，但是参数不同。
方法都在同一个类里面。
方法的覆盖(Override)
前提是需要有继承关系，涉及到两个类，父类和子类。
方法重写：
子类重新定义父类的同名方法，主要是重写定义方法体。
父类是公有的修饰符，子类一定是公有的。父类如果是protected，子类可以是protected，或者public
子类比父类更开放。
3.子类重写的方法的返回值类型可以是跟父类一样，或者是父类返回值类型的子类。
super关键字（this关键字 ---当前对象）
可以通过super.属性名调用从父类继承过来的属性
通过super.方法名调用父类定义的方法
通过super()调用父类的构造方法。
定义子类对象，调用父类的构造方法的时候，一定子类构造方法的第一行，并且不一定就是调用空参数的父类的构造方法，只要是调用父类随便一个构造方法都可以，但是，只能调用一次。
public Dog(){
super(30);//首先调用父类的无参的构造方法
System.out.println();
}
Java继承的限制：
1.继承只能是单继承，只能有一个直接父类。 只能有一个爹
2.可以多层继承，父类有父类 爷爷
3.私有的属性和方法不能被继承 私有就是为了自己类可用，子类当然不能用
课堂代码：
public class Animal {
public Animal(int age, char sex) {
this.age = age;
this.sex = sex;
}
public Animal(){
System.out.println("---------Animal Constructor-----------");
}
protected int age=0;
private char sex;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
/**
* 吃饭
*/
public void eat(){
System.out.println("I can eat");
}
/**
* 睡觉
*/
protected void sleep(){
System.out.println("I can sleep 8 hours");
}
/**
* 发出叫声
*/
public void call(){
System.out.println("call.......................");
}
public Animal getAnimalInstance(){
return new Animal();
}
}
package yantai;
public class Dog extends Animal{
int age=1;
@Override
public Dog getAnimalInstance() {
// TODO Auto-generated method stub
return null;
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("8 hours");
}
public Dog(){
super(12,‘f‘);
System.out.println("------Dog constructor---------");
}
/**
* 看门
*/
public void watchDoor(){
System.out.println("I can watchDoor");
}
public void print(){
System.out.println("the age is :"+super.age);
}
}
多态
多态需要具备什么前提？
类之间有继承关系
多个子类需要对父类的某个方法进行重写。
3.一个父类的引用指向一个子类的对象。
Animal a = new Dog();
Animal a = new Cat();
Animal a = new Pig();
多个子类共同继承父类，定义时候用父类变量分别指向不同子类对象
注意：
父类的引用指向子类的对象，但是父类的引用只能访问到父类定义的方法声明。
他访问父类当中被重写的方法，最终是访问子类的方法。
多态总结：一个变量能做什么要由类型决定，一个变量怎么做由对象决定。
深度分析: invokespecial选择方法基于引用的类型，而不是对象所属的类。但invokevirtual则选择当前引用的对象
课堂举例：动物发出叫声的多态----玩具
package com;
public class Animal {
private int age;//年龄
private char sex;//性别
private String skin;//肤色
private String type;//类型
public Animal(){
}
/**
* 睡觉
*/
protected void sleep(){
System.out.println("-------------sleep 8 hours---------------");
}
/**
* 吃饭
*/
public void eat(){
System.out.println("-------------eat something---------------");
}
/**
* 叫声
*/
public void call(){
System.out.println("-------------calling....---------------");
}
}
class Dog extends Animal{
public void call(){
System.out.println("-------------wangwang....---------------");
}
}
class Pig extends Animal{
public void call(){
System.out.println("-------------hengheng....---------------");
}
}
class Cat extends Animal{
public void call(){
System.out.println("-------------miaomiao....---------------");
}
}
Toy.java
package com;
public class Toy {
public static void main(String[] args) {
// TODO Auto-generated method stub
Toy toy=new Toy();
toy.pressButton(new Dog());
toy.pressButton(new Cat());
}
public static void pressButton(Animal a){
//根据信号来判断这是什么动物，然后发出声音
a.call();
}
}
台灯发光的问题。
一盏台灯，换上不同颜色的灯泡会发出不同颜色的光。
标签：
原文地址：http://blog.csdn.net/hannaseyes/article/details/51364586
