黑马程序员系列第六篇面向对象基础

2019-11-14 15:02:58

字体：大中小

来源：转载

供稿：网友

asp.net+Android+IOS开发、Net培训、期待与您交流！

（前言：本篇文章主要依据毕向东老师的课程视频整理而成，如要详细学习，请观看毕老师视频百度网盘链接地址：http://pan.baidu.com/s/1mgngVl2）

目录：1、面向对象三大特性 2、类和对象 3、内部类

1、面向对象三大特性封装、继承、多态

封装

概念:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

继承

好处：子类将得到基类中的所有域和方法，提高了代码的复用性；让类与类之间产生了关系，提供了另一个特征多态的前提。

多态

简单例子：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提： 1：必须要有关系，比如继承、或者实现。 2：通常会有覆盖操作。

关于基于继承的多态的一个代码示例

 1 /* 2 对象的多态性：动物 x = new 猫(); 3 函数的多态性：函数重载、重写 4  5 1、多态的体现 6         父类的引用指向了自己的子类对象 7         父类的引用也可以接收自己的对象 8 2、多态的前提 9         必须是类与类之间只有关系，要么继承或实现10         通常还有一个前提，存在覆盖11 3、多态的好处12         多态的出现大大的提高了程序的扩展性13 4、多态的弊端14         只能使用父类的引用访问父类的成员15 5、多态的应用16 17 6、注意事项18 */19 20 /*21 需求：22 猫，狗。23 */24 25 abstract class Animal26 {27     abstract void eat();28 }29 30 class Cat extends Animal31 {32     public void eat()33     {34         System.out.PRintln("吃鱼");35     }36     public void catchMouse()37     {38         System.out.println("抓老鼠");39     }40 }41 42 class Dog extends Animal43 {44     public void eat()45     {46         System.out.println("吃骨头");47     }48     public void kanJia()49     {50         System.out.println("看家");51     }52 }53 54 class DuoTaiDemo55 {56     public static void main(String[] args)57     {58         function(new Cat());59         function(new Dog());60         61         Animal a = new Cat();//向上转型62         a.eat();63         64         Cat c = (Cat)a;//向下转型65         c.catchMouse();66         67         68     }69     70     public static void function(Animal a)71     {72         a.eat();73         //用于子类型有限74         //或判断所属类型进而使用其特有方法75         if(a instanceof Cat)76         {77             Cat c = (Cat)a;78             c.catchMouse();79         }80         else if(a instanceof Dog)81         {82             Dog c = (Dog)a;83             c.kanJia();84         }85     }86     87     88 }

2、类和对象

类：一个类可以被定义为描述行为的模板/蓝色印花/指出其类型支持的对象。

对象：对象具有状态和行为。例如：狗有状态 - 颜色，名称，繁殖以及行为，摇头晃脑，吠叫，吃。对象是类的实例。

从类创建对象时有三个步骤：

1、声明: 变量声明，一个变量名的对象类型。

2、实例: “new”关键字是用来创建对象。

3、初始化: 关键字 new 后跟调用一个构造函数。这个调用初始化新的对象。

关于构建类的一个简单例子：

 1 public class Employee{ 2    String name; 3    int age; 4    String designation; 5    double salary; 6      7    // This is the constructor of the class Employee 8    public Employee(String name){ 9       this.name = name;10    }11    // Assign the age of the Employee  to the variable age.12    public void empAge(int empAge){13       age =  empAge;14    }15    /* Assign the designation to the variable designation.*/16    public void empDesignation(String empDesig){17       designation = empDesig;18    }19    /* Assign the salary to the variable    salary.*/20    public void empSalary(double empSalary){21       salary = empSalary;22    }23    /* Print the Employee details */24    public void printEmployee(){25       System.out.println("Name:"+ name );26       System.out.println("Age:" + age );27       System.out.println("Designation:" + designation );28       System.out.println("Salary:" + salary);29    }30 }

3、内部类

定义：将一个类的定义放在另一个类的定义内部。

规则：内部类的创建和普通类没区别；

内部类可以直接访问所属外部类中的成员（包括私有的）

访问格式：外部类名.this.成员名，成员名不冲突是可直接用成员名调用，所属的外部类要访问内部类必须要建立内部类对象。

局部内部类：1、不可以被成员修饰符修饰 2、可以直接访问外部类的成员，因为还只持有外部类的引用，在所在的局部中只能访问它所在的局部中的用final修饰的变量。

匿名内部类（其实就是内部类的一种简写格式）：定义匿名内部类的前提----内部类必须是继承一个类或者实现接口；

格式：new 父类名字（）{子类实现的内容}；

几种内部类的代码演示：

 1     public static void main(String[] args) { 2         //创建非静态内部类的对象 3         Test.TestInner tt=new Test().new TestInner(); 4         tt.show1(); 5         tt.show(); 6         tt.show2(); 7         //创建静态内部类的对象 8         Test.Test1Inner tt1=new Test.Test1Inner(); 9         tt1.show();10         //直接调用静态内部类中的静态方法11         Test.Test1Inner.show1();12         13         Test tn=new Test();14         tn.show();//验证局部内部类15         tn.show1();//验证匿名内部类16     }17 18 }19 class Test{20     int a=1;21     public void show(){22         final int  a=90;23         System.out.println("Test show a:"+a);24         new TestInner().show();//外部类非静态方法访问非静态内部类中的方法25         //局部内部类,调用方法中的局部变量要被final修饰26         class MethodClass{27             public void show1(){28                  System.out.println("Test show1 MethodClass show1 a:"+a);29             }30         }31         new MethodClass().show1();32     }33     public void show1(){34         //匿名内部类,直接在对象后使用其重写的方法,调用方法中的局部变量要被final修饰35         final int a=80;36         new Test2(){37             @Override38             public void show() {39                 System.out.println("大家好，这里是Test类中的show1方法中继承了Test2抽象类的匿名内部类..."+a);40             }41             42         }.show();43     }44     //普通内部类45     class TestInner{46         int a=2;47         public void show(){48             System.out.println("TestInner show a:"+a);49         }50         public void show1(){51             System.out.println("Test TestInner show1----:");52             Test.this.show();//非静态内部类访问所属外部类的非静态方法53         }    54         public void show2(){55             System.out.println("Test TestInner show2----:");56             new Test.Test1Inner().show();//非静态内部类访问所属外部类的静态类的方法57         }58     }59     //静态内部类60     static class Test1Inner{61          static int a=9;62          public void show(){63            new Test().new TestInner().show();//静态内部类调用非静态内部类中的方法64          }65          public static void show1(){66              System.out.println("Test Test1Inner show1 a:"+a);67          }68     }69 }70 abstract class Test2{71     public abstract void show();72 }