疯狂java学习笔记之面向对象(五) - 封装、继承、多态

一、封装:

封装的概念:

　　- 合理的隐藏:隐藏不想被外界操作的Field、方法、构造器

　　- 合理的暴露:一般就是希望给别人调用的方法

　　e.g:显示器(按键暴露出来操作,但实际的东西/细节方法被隐藏起来)

封装的目的：

　　- 简化编程(不去去找显示器的内部调,直接按键调整即可)

　　- 更好的保证对象的完整性

为了实现隐藏，我们有4个修饰符：

　　private 　　　　 - 仅限当前类访问权限

　　无修饰符/默认 　 - 包访问权限(同一个包内)

　　protected 　　   - 子类访问权限(本类能访问、同一个包也能访问)

　　public 　　　　   - 公共的访问权限

　　权限级别:private → 默认访问权限 → protected → public (只有成员变量才需用访问权限修饰符)

　　private 　　 - 用于隐藏Field

　　public 　　   - 专门用于暴露方法

　　protected    - 希望被它的子类访问的方法

　　默认            - 希望在同一个包中被访问

局部变量方法一执行完就销毁了,所以没必要限制,限制了也没意义,它尽在方法内或代码块中有效,作用域本来就小-连方法都出不了,所以它用访问权限修饰符都是多余(默认都多余)

 class Fruit {
     private double weight;
     private String name;

     public void grow(double grow){
         if(this.weight + grow >= 100){
             System.out.println("水果超出重量,逆天了！");
         }else{
             weight = weight + grow;
         }
     }

     public void setName(String name){
         if(name.length() > 6 || name.length() < 2){
             System.out.println("水果名字不符合规则");
         }else{
             this.name = name;
         }
     }

     public void info(){
         System.out.println("这个是:" + name + ",重量为:" + weight);
     }
 }

 class TestFruit{
     public static void main(String[] args){
         Fruit t = new Fruit();
         //t.weight = 200;   定义为private后不能直接赋值
         //t.name = "Apple"; 如果直接赋值将破坏Fruit对象的数据完整性
         t.grow(10);
         //t.grow(101); //不符合定义规则打印对应语句
         //t.setName("A");
         t.setName("Apple");
         t.info();
     }
 }

二、继承:(extends)

　　Java的继承 - 两个类之间的关系(A extends B),Java中的继承从"一般到特殊"的关系,如:

　　人 → 老师 → IT老师 → 教Java的老师

　　Java通过关键字extends来实现，实现继承的类称为子类,被继承的类称为基类/超类/父类，父类是大类(范围大)，子类是小类

　　Java的继承是单继承，每个继承类(extends后面)只能有一个直接父类但可以有N个间接父类,子类继承了父类 仅【能】获得父类的全部属性和方法但【不能】获得父类的构造器、初始化块、内部类

　　如果定义的Java类没有显示的指定父类,系统默认会让它继承Object类--一切的类都是Object类的子类

 public class Person {
     private String name;
     private int age;

     public Person(){} //父类空构造器,子类初始化是会报错

     public Person(String name , int age){
         this.name = name;
         this.age = age;
     }

     public void info(){
         System.out.println("这人叫:" + name + ",年龄是:" + age);
     }

     public static void main(String[] args) {
         Person p = new Person("小二",20);
         p.info();
     }
 }

 public class Teacher extends Person{
     public static void main(String[] args){
         //子类将会从父类那里获取到所有方法
         Teacher t = new Teacher();
         //调用从父类那里继承到的方法
         t.info();
     }
 }

　　

继承中父类与子类的关系是"一般到特殊的关系",所以子类的实例完全可以当作父类的对象来使用,父类的引用变量完全可以指向子类的实例。

 class Animal{
     private String name;
     private String sex;

     public Animal(String name , String sex){
         this.name = name;
         this.sex = sex;
     }

     public void info(){
         System.out.println("动物的名字叫:" + name + ",性别为:" + sex);
     }
 }

 public class TestAnimal extends Animal{
     private String color;

     public TestAnimal(String name , String sex , String color){
         super(name,sex);
         this.color = color;
     }

     public static void test(Animal A){
         System.out.println("~这是个测试方法~");
         A.info();
     }

     public static void main(String[] args){
         Animal ta = new TestAnimal("灰太狼","male","灰色");
         TestAnimal.test(ta);
     }
 }

三、多态：

　　同一类型的变量,在访问同一方法时, 呈现出多种行为特征 -- 这就是多态。

　　多态增加了Java语言的灵活性,它是和设计模式紧密相连的。

 class Person{
     public void work(){
         System.out.println("努力工作！");
     }
 }

 class Teacher extends Person{
     @Override
     public void work(){
         System.out.println("辛勤的教书！");
     }
 }

 class Student extends Person{
     @Override
     public void work(){
         System.out.println("努力的读书！");
     }

     public void play(){
         System.out.println("读书真累啊！");
         System.out.println("累的时候也要适当的玩耍啊！");
     }
 }

 public class Duotai{
     public static void main(String[] args) {
         //多态:同一个类型的变量在访问同一个方法时,表现出多种行为特征
         //p、p1、p2均为person类型变量,但在访问work方法时返回的结果都不一样则为多态
         Person p = new Person();
         p.work();
         //子类的实例/对象完全可以当成父类的对象来使用
         //p1引用变量指向Teacher实例
         Person p1 = new Teacher();
         p1.work();
         Person p2 = new Student();
         p2.work();
         //编译阶段不管运行时类型的,编译器并不知道引用变量实际引用的对象时Student,编译器只知道它的编译时类型为Person,而Person又没有play()方法,所以编译报错
         //p2.play();
         //若要调用play()方法,则可以使用Student来定义变量,或者使用强制转换将p2转换成student对象
         Student st = (Student)p2;
         st.play();

         Student p3 = new Student();
         p3.play();
     }
 }

Java的引用变量有两个类型:

　　1、编译时类型:由声明它的类型来决定所以p、p1、p2的编译类型均为Person,p3的编译类型为Student；

　　2、运行时类型:由该引用变量实际所指向的对象决定p的为Person,p1 为Teacher, p2为Student,p3为Student,当我们调用引用变量时,它总是呈现它的运行时的特征.