面向对象的三大坏处

三大特性

1.封装(数据的隐藏)

程序设计要求高内聚，低耦合，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴露少量的方法给外部使用

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

//类  private:私有
public class Student {

           private String name;      //名字
           private int id;           //学号
           private char sex;         //性别
           private int age;         //年龄

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
        //在存值的的时候也可以做一些简单的判断
            if (age<0 || age>120){      //不合法默认3岁
                this.age = 3;
            }else {
                this.age = age;			//合法就存进去
            }
        }
		//提供一些可以操作这个属性的方法!
        //提供一些public 的get，set方法

        //get 获得这个数据
        public String getName(){
            return this.name;
        }

        //set 给这个数据设置值
        public void setName(String name){

            //main方法传过来的name，赋值给this.name当前方法的name，this就是指向当前study类；
            this.name = name;
        }
        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getSex() {
            return sex;
        }

        public void setSex(char sex) {
            this.sex = sex;
        }
}

2.继承

java中类只有单继承，没有多继承，可以间接继承多个.
在java中，所有的类，都默认直接或者间接继承object
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示
子类继承父类的方法，就会继承父类的所有方法，

public class Subclass extends Parent{
	//子类
 public void test(String name){
        System.out.println(name);           			//传进来的值    
        System.out.println(this.name);					//当前类name的值
        System.out.println(super.name);					//父类name的值
    }
    }

public class Parent {
	//父类
    public  String name = "李锐";

   public static void main(String[] args) {
   //mian方法
	Subclass s = new Subclass();
    s.test("小锐");			

运行结果

.

3.多态

多态就是“同一个行为”发生在“不同的对象上”会产生不同的效果

多态的有哪些条件

要有继承/实现关系
要有方法重写
要有父类引用指向子类对象

多态的成员特点

成员变量：编译看左边、运行看左边
成员方法：编译看左边、运行看右边
父类的对象变量可以引用本类的对象，也可以引用子类的对象。

特殊运算符:instanceof属性
用来判段两个对象是否相等

子类的对象变量可以引用父类的对象吗？

答案当然是不可以了，就好比如int类型赋值给byte类型，是不是大转小啊，需要强制转换
同理当把父类的对象赋值给子类的对象时，需要强制转换，

即对象类型的转换分为以下两种：

       （1) 向上转型:　子类的对象可以直接赋给父类的对象变量。　
			格式:  (类型名) 对象变量;

这种现象也称之为类型的自动转换。

       （2） 向下转型:  将父类的引用强制转换成子类的引用。　

当父类对象变量引用了子类的对象时，则问: 父类的对象变量是否可以直接调用子类的特有方法？

       也是不可以的，需要强制转换

       例如: Animal 是父类,  Dog是子类,  而show()方法是Dog子类特有的方法。

                因此, 当有  Anaimal  a = new Dog(); 时,
			将父类强转为子类	Dog d = new （Dog）a；
               					d.show（）；

什么情况下需要将对象的引用实现强制转换

       （1）一定是发生多态:
	   （2）一定是想要去访问（调用）子类对象的特有属性或方法。
	   
          父类的对象变量引用了子类的对象。
          Object obj = new Student();
          
          ((子类类名)父类的对象变量).子类对象的特有方法（属性）; //则对了。
          Stringstr = ((Student)obj).getSchool();  //对了。

三大特性的特点

封装性: 安全性和重用性。

继承性: 高效性和重用性。

多态性: 统一性(有机性)和高效性。