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

 

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

 

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

 

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

封装

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

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

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

继承

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

多态

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

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

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

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

 

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

/*
对象的多态性：动物 x = new 猫();
函数的多态性：函数重载、重写

1、多态的体现
        父类的引用指向了自己的子类对象
        父类的引用也可以接收自己的对象
2、多态的前提
        必须是类与类之间只有关系，要么继承或实现
        通常还有一个前提，存在覆盖
3、多态的好处
        多态的出现大大的提高了程序的扩展性
4、多态的弊端
        只能使用父类的引用访问父类的成员
5、多态的应用

6、注意事项
*/

/*
需求：
猫，狗。
*/

abstract class Animal
{
    abstract void eat();
}

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void kanJia()
    {
        System.out.println("看家");
    }
}

class DuoTaiDemo
{
    public static void main(String[] args)
    {
        function(new Cat());
        function(new Dog());
        
        Animal a = new Cat();//向上转型
        a.eat();
        
        Cat c = (Cat)a;//向下转型
        c.catchMouse();
        
        
    }
    
    public static void function(Animal a)
    {
        a.eat();
        //用于子类型有限
        //或判断所属类型进而使用其特有方法
        if(a instanceof Cat)
        {
            Cat c = (Cat)a;
            c.catchMouse();
        }
        else if(a instanceof Dog)
        {
            Dog c = (Dog)a;
            c.kanJia();
        }
    }
    
    
}    

 

2、类和对象  

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

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

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

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

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

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

 

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

public class Employee{
   String name;
   int age;
   String designation;
   double salary;
    
   // This is the constructor of the class Employee
   public Employee(String name){
      this.name = name;
   }
   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge){
      age =  empAge;
   }
   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* Assign the salary to the variable    salary.*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* Print the Employee details */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

 

 

3、内部类  

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

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

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

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

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

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

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

 

几种内部类的代码演示：

    public static void main(String[] args) {
        //创建非静态内部类的对象
        Test.TestInner tt=new Test().new TestInner();
        tt.show1();
        tt.show();
        tt.show2();
        //创建静态内部类的对象
        Test.Test1Inner tt1=new Test.Test1Inner();
        tt1.show();
        //直接调用静态内部类中的静态方法
        Test.Test1Inner.show1();
        
        Test tn=new Test();
        tn.show();//验证局部内部类
        tn.show1();//验证匿名内部类
    }

}
class Test{
    int a=1;
    public void show(){
        final int  a=90;
        System.out.println("Test show a:"+a);
        new TestInner().show();//外部类非静态方法访问非静态内部类中的方法
        //局部内部类,调用方法中的局部变量要被final修饰
        class MethodClass{
            public void show1(){
                 System.out.println("Test show1 MethodClass show1 a:"+a);
            }
        }
        new MethodClass().show1();
    }
    public void show1(){
        //匿名内部类,直接在对象后使用其重写的方法,调用方法中的局部变量要被final修饰
        final int a=80;
        new Test2(){
            @Override
            public void show() {
                System.out.println("大家好，这里是Test类中的show1方法中继承了Test2抽象类的匿名内部类..."+a);
            }
            
        }.show();
    }
    //普通内部类
    class TestInner{
        int a=2;
        public void show(){
            System.out.println("TestInner show a:"+a);
        }
        public void show1(){
            System.out.println("Test TestInner show1----:");
            Test.this.show();//非静态内部类访问所属外部类的非静态方法
        }    
        public void show2(){
            System.out.println("Test TestInner show2----:");
            new Test.Test1Inner().show();//非静态内部类访问所属外部类的静态类的方法
        }
    }
    //静态内部类
    static class Test1Inner{
         static int a=9;
         public void show(){
           new Test().new TestInner().show();//静态内部类调用非静态内部类中的方法
         }
         public static void show1(){
             System.out.println("Test Test1Inner show1 a:"+a);
         }
    }
}
abstract class Test2{
    public abstract void show();
}

 

 

 

       初学者难免错误，欢迎评判指教，持续更正ing...........