面向对象的基本知识

                                            

学习面向对象的基础知识，需从以下三个方面来学习：(1)什么是面向对象？(2)应如何学习面向对象？(3)面向对象的思维方式是什么？

(1)什么是面向对象？
     面向对象是一种编程方法；
     面向对象是一种思维方式；
     面向对象是一种编程语言；

(2)应如何学习面向对象？
      掌握一门面向对象语言的语法；
      掌握面向对象的思维方式；
      熟悉面向对象的设计原则；
      掌握面向对象的设计模式；

(3)什么是面向对象的思维方法？
       首先确定谁来做，其次确定怎么做；
       首先考虑整体，其次考虑局部；
       首先考虑抽象，其次考虑具体；

一. 首先我们来简单说一下创建类的方法，创建对象的方法，函数的重载。

1.1创建类的方法

     
     

      
      

       
       class类名{
      
      
      
      

       
       属性;
      
      
      
      

       
       方法;
      
      
      
      

       
       }
      
      
     
     

      属性顾名思义就是成员变量，主要用于描述类的状态；

      方法即成员方法，主要用于描述类的行为；   

用一个简单的代码来说一下类是如何创建的。

   
   

    
    

     
     classPerson{
    
    
    
    

     
     String name;//成员变量
    
    
    
    

     
     void talk(){//成员函数
    
    
    
    

     
     System.out.println("my name is "+ name);
    
    
    
    

     
     }
    
    
    
    

     
     }
    
    
   
   

1.2创建对象的方法

          格式：类名  对象名 =  new  类名()

          例如：Dog  dog = new Dog()

   

类是抽象的，对象是具体的。

1.3函数的重载

构成函数重载的标准：两个函数处于同一个类中 ；两个函数的函数名相同；两者的参数不同。

首先创建一个类A,其代码如下：

   
   

    
    

     
     class A{
    
    
    
    

     
     	A(){
    
    
    
    

     
     System.out.println("我是构造函数");
    
    
    
    

     
     }
    
    
    
    

     
     void funA(){
    
    
    
    

     
     System.out.println("没有参数的funA函数");
    
    
    
    

     
     }
    
    
    
    

     
     void funA(int i){
    
    
    
    

     
     System.out.println("拥有一个整型参数的funA的函数");
    
    
    
    

     
     }
    
    
    
    

     
     void funA(int i ,double j){
    
    
    
    

     
     System.out.println("拥有两个参数的funA的函数");
    
    
    
    

     
     }
    
    
    
    

     
     }
    
    
   
   

其次创建一个主函数来调用类中的成员函数，其代码如下：

    
    

     
     

      
      classTest{
     
     
     
     

      
      publicstaticvoid main(String args[])}{
     
     
     
     

      
      	A.a =new A();
     
     
     
     

      
      	a.funA();
     
     
     
     

      
      }
     
     
     
     

      
      }
     
     
    
    

打印输出的结果取决于调用a.funA()中的参数，若无参数说明输出结果为：" 没有参数的funA函数"，若参数为一个整型变量说明输出结果为："拥有一个整型参数的funA函数"，若参数为整型和双精度浮点型的说明输出结果为："拥有两个参数的funA的函数"。

构造函数的作用：(1)new后面的调用的是构造函数；(2)构造函数的名字必须和类名一样（大小写必须保持一致）；

(3)无返回值类型的定义；(4)使用new 来调用构造函数；(5)如果在类中 无构造函数，编译器会自动加一个参数为空，方法体为空的构造函数，若类中有构造函数，此时编译器则不会添加一个参数为空，方法体为空的构造函数。可以从以下代码中知晓：

    
    

     
     

      
      classPerson{
     
     
     
     

      
      Person(){//这是一个参数为空，方法体为空的构造函数；
     
     
     
     

      
      }
     
     
     
     

      
       //Person(String n ,int a){
     
     
     
     

      
          name = n;
     
     
     
     

      
          age = a;
     
     
     
     

      
      }//这样写的目的在于避免在主函数中出现的重复代码；

     
     
     
     

      
      String name;
     
     
     
     

      
      int age;
     
     
     
     

      
      }
     
     
    
    

    
    

     
     

      
      classTest{
     
     
     
     

      
      publicstaticvoid main(String args[])}{
     
     
     
     

      
          Person p = new Person();
     
     
     
     

      
      	//Person p1 =newPerson();
     
     
     
     

      
      	p1.name ="zhangsan";
     
     
     
     

      
      	p1.age =10;
     
     
     
     

      
      Person p2 =newPerson();
     
     
     
     

      
      	p2.name ="lisi";
     
     
     
     

      
      	p2.age =12;//这样在代码中会出现明显的重复,此时修改构造函数，避免重复；
     
     
     
     

      
          Person p1 = new Person("zhangsan",10);
     
     
     
     

      
          Person p2 = new Person("lisi",12);//调用有参数的构造函数；
     
     
     
     

      
      }
     
     
     
     

      
      }
     
     
    
    

二.其次我们来说一下this的使用。

2.1this的使用

   (1)使用this调用成员变量和成员函数；

   (2)使用this调用构造函数；

   this调用成员变量和成员函数的代码如下：

    this代表调用函数的当前对象

    
    

     
     

      
      classPerson{
     
     
     
     

      
      String name ;
     
     
     
     

      
      void talk(String name ){
     
     
     
     

      
      System.out.println("my name is "+this.name);//在调用成员变量的时候应该是对象.成员变量
     
     
     
     

      
      	 }
     
     
     
     

      
      }
      
       
     
     
    
    

在这个代码中，会让人有一种迷惑存在,无法区分到底是成员变量name,还是参数name。此时可以用成员函数中有无参数来判断，若无参数则不用this，若有参数则用this.成员变量。

     this调用构造函数（为了解决在本类中出现的重复代码）其代码如下：

    
    

     
     

      
      classPerson{
     
     
     
     

      
      String name ;
     
     
     
     

      
      int age ;
     
     
     
     

      
      String address;
     
     
     
     

      
      Person(){
     
     
     
     

      
      System.out.println("无参数的构造函数");
     
     
     
     

      
      }
     
     
     
     

      
      Person(String name ,int age){
     
     
     
     

      
      this.name = name;
     
     
     
     

      
      this.age = age;
     
     
     
     

      
      }
     
     
     
     

      
      Person(String name,int age,String address){
     
     
     
     

      
      this(name, age);//避免重复代码，需放在构造函数的第一个语句。其作用是：调用本类中的另外两个参数，根据参数的个数和参数的类型；
     
     
     
     

      
      this.address = address;
     
     
     
     

      
      }
     
     
     
     

      
      void talk(){
     
     
     
     

      
      System.out.println("my name is "+ name)
     
     
     
     

      
      }
     
     
     
     

      
      }
     
     
    
    

 三.我们知道造面向对象的程序设计中具有三个特点：封装性，继承性，多态性.

      在这里重点说一下继承性。我们需要明白三个问题：什么是继承，为什么要使用继承，继承的基本语法特点。

3.1继承

    顾名思义就是在面向对象的世界中，就是一个类得到了另外一个类的成员和成员函数

    在Java中只允许单继承，不允许多继承。

                                 

    
    

     
     

      
      classPerson{
     
     
     
     

      
      String name;
     
     
     
     

      
      int age;
     
     
     
     

      
      void introduce(){
     
     
     
     

      
      System.out.println("我的名字是"+ name,+"我的年龄是"+ age);
     
     
     
     

      
      }
     
     
     
     

      
      }
     
     
    
    

     
     

      
      

       
       classStudentextendsPerson{
      
      
      
      

       
       int grade;
      
      
      
      

       
           void study(){
      
      
      
      

       
       System.out.println("学习");//子类继承了父类中的成员变量和成员函数，也可以定义自己的成员变量和成员函数；
      
      
      
      

       
       }
      
      
      
      

       
       }
      
      
     
     

      
      

       
       

        
        classTest{
       
       
       
       

        
        publicstaticvoid main(String args[])}{
       
       
       
       

        
        Student student =new student();
       
       
       
       

        
        	  student.name ="zhangsan";
       
       
       
       

        
        	  student.age =18;
       
       
       
       

        
        	  student.introduce();//student继承了父类的一些成员变量和成员函数，减少了重复代码，因为如果不利用继承的关系，在student这个类中会出现重复代码；
       
       
       
       

        
        }
       
       
       
       

        
        }