面向对象思想

面向对象思想(理解)

  a.面向对象与面向过程对比:

    面向对象注重的是结果,不注重过程

    面向过程既注重过程也注重结果,面向过程得实现每个细节

举例:烤鸭:

          面向过程:鸭苗慢慢养大变成鸭大

                   烤箱

                   拔毛洗鸭子掏内脏

                   配料涂抹鸭子

                   扔进烤箱拷

                   出炉吃胡的鸭子

          面向对象:

                 请去全聚德

                 给钱

                 吃鸭子

 

面向对象的优点

 

    1.面向对象由原来的执行者变成了指挥者(调用者,领导者)

 

    2.面向对象思想更贴近于现实生活

 

    3.面向对象可以讲复杂事物简单化,因为面向对象只注重结果

局部变量与成员变量

1.定义位置

       局部变量:方法内

       成员变量:类内方法外

2.作用域

       局部变量:方法内

       成员变量:整个类都能使用

3.默认值与所在内存空间

       局部变量:方法栈,和方法同生(随着方法入栈)共死(方法执行完局部变量也被销毁),局部变量没有默认值,要想使用必须先赋值后使用

       成员变量:堆中,和对象同生(new的时候属性存在于堆中)共死(堆中的对象被回收),有默认值

面向对象之封装

封装的体现

     类:封装了属性和方法

     方法:封装了很多语句

封装的好处:

      1.提高代码的安全性(为年龄在setAge()加判断)

      2.提高了代码的复用性(例如方法一旦定义好可以多次调用)

   c.封装的实现:private,getter与setter

this关键字作用

     1.为了区分成员变量和局部变量

     2.谁调用成员方法,该成员方法中的this就指向谁

继承

概述

    1.有继承关系的两个类必须遵循现实事物的客观规律

　2.子类会自动拥有父类的所有非private修饰的成员(成员属性和成员方法)

继承的优点

     1.在父类中定义的所有子类共有的属性和方法,子类继承父类,子类中就不用再重复定义

       提高了代码的重用性

 

继承的注意事项

 

     1.Java中的继承都是单继承

     2.Java中所有的类都直接或间接继承自Object类

       Java中所有的类都具有Object类中非private成员属性和方法

重载和重写对比:

权限修饰符

           重载:与权限修饰符无关

           重写:子类的方法的权限>=父类的方法的权限(如果父类是private,子类就不能继承,何谈重写)

方法名

           重载:重载的两个方法名必须相同

           重写:重写的两个方法名也是必须相同

形参列表

           重载:重载的两个方法形参列表必须不同

                 形参类型

                 形参个数

                 形参类型的顺序

                 以上三点至少满足一个

           重写:重写的两个方法形参列表必须相同

 

返回值类型

           重载:重载与返回值类型无关

           重写:重写的两个方法返回值必须相同

抽象类特点

    1.抽象的类不能new对象

    2.含有抽象方法的类一定是抽象类

    3.抽象类既可以有抽象方法,也可以有非抽象方法

    4.抽象类中可以没有一个抽象方法,作用

      a.不想让该类创建对象

      b.子类继承该抽象类,可以直接拿到抽象类中的方法使用

接口

概念

    接口是一种约束,规则,规范

    例如:

      笔记本上的各种接口:例如USB接口,要想传输数据必须实现USB接口上的规范(设备得制作成方形,还得有4个金属触点)

      电源接口:电源要么有两相,要么有三相的,这个是由电器协会规定的

特点:

   1.接口中所有的方法都是抽象方法

   2.接口中的变量都是常量

   3.要想使用接口不能创建接口的对象,因为接口中的所有方法都是抽象方法

     new 接口调用抽象没有任何意义.必须创建一个类去实现接口,然后创建该实现类的对象

定义:(重点)

interface Father{
      public abstract void method();//接口中方法的修饰符,可写可不写或者写一部分
                                   //但是在编译后方法上的修饰符一定是public abstract
      
      void method(int i);//虽然什么都没写,最后还是要被编译器加上public abstract
      public void method(double i);//虽然只写了public,最后还是要被编译器加上public abstract

      public static final int a=3;//static:在类外可以直接通过Father.a来调用不用再创建对象,然后通过
                                  //对象名来调,简化了书写 
                                  //final:被final修饰的变量是常量(恒定不变的量),一旦被final修饰,只能赋值一次
                                  //Father.a=10;//错误,不能重复赋值
                                    Father.a;
                                    Father f=new Father()
                                    new Father().a
   }

接口的使用方式:

    1.一个类实现一个接口
    interface Father{
       public abstract void method(); 

    }
    class Son implements Father{
       @Override//防止忘掉重写
       public void method(){

       }
    }  
    Son son=new Son();
    son.method(); 
   2.一个类只实现了接口中的部分抽象方法
       interface Father{
          public abstract void method(); 
          public abstract void method2(); 
       }
        abstract class Son implements Father{//因为Son类仅实现了method()方法,而method2()这个抽象方法被继承下来没有重写
                                             //那么这个Son类依然是抽象类(含有抽象方法的类一定是抽象类)
          @Override//防止忘掉重写
          public void method(){

          }
       }  
    3.一个类实现多个接口:接口中的方法都是抽象方法
      interface Father{
         public abstract void method(); 
      }
      interface GanFather{
        public abstract void method(); 
      }
      abstract class Son implements Father,GanFather{ 
         @Override
         public void method(){//由于接口中的方法都是抽象方法,那么Father接口中的method()和ganFather中的method()方法
                              //同时被重写(实现)

         }
      }  
    4.一个实现继承类的同时还实现接口
      interface Father{
         public abstract void method(); 
      }
      interface GanFather{
        public abstract void method(); 
      }
      class OldGanMother{
          public void oldGanMotherJiang(){
              System.out.println("老干妈牛肉酱,拌饭吃着香");
          }
      }
     class Son extends OldGanMother implements Father,GanFather{ 
         @Override
         public void method(){ 

         }

      }  
    5.一个接口可以继承多个接口:因为接口中的方法都是抽象方法,没有方法体,不会存在歧义
      interface Father{
         public abstract void method(); 
      }
      interface GanFather{
        public abstract void method(); 
      }
      interface GanDaughter extends Father,GanFather{

      }

抽象类和接口对比:

相同点:

       1.抽象类和接口中都可以含有抽象方法

       2.都不可以直接new对象

       3.都需要子类来继承或者实现

不同点:

       1.接口中的方法一定是抽象方法,并且都是public abstract修饰

       2.一个类只能继承一个抽象类,但是一个类可以实现多个接口

多态

概述(多种形态)

  　人的一生:(人的一生有很多形态,但是自始自终都是一个人)

                 人

       宝宝,孩子,学生,程序员,丈夫,爸爸,爷爷,曾爷爷,go to dead

封装:

     类和方法体现

     封装提高了代码复用性

继承:

     实现了父子关系,让类与类产生关系

     继承提高了代码复用性,为多态提供了前提条件

多态:

     父类引用指向子类对象

     多态提高了代码的复用性和拓展性

构造方法(构造函数,构造器 constructor)

作用

     在创建该类的对象的时候,给该类的属性赋值(初始化该类属性)

注意事项

     1.如果一个类中没有写任何构造函数,编译器在编译该类后会默认添加一个空参构造

         public 类名(){

        }  

       如果手动给出的构造方法,编译器就不在添加默认构造方法,想用,手动写

     2.在new对象的时候一定会找相应形参的构造方法执行

this与super

 

 a.this关键字

 

    1.this关键字:

 

      a.我们可以使用this.成员变量名来区分同名的成员变量和局部变量

 

      b.构造方法和非static修饰的方法都有this引用,谁new对象,或者是通过对象调用方法,

 

        该方法(构造方法和成员方法)this就指向调用方法的对象 (简单来说:谁调用我,我就指向谁)

 

    2.this(参数)//this语句:

 

      1.this(参数)调用本类中的其它构造方法,调用的构造方法由传递参数来决定

 

      2.this()语句一定放在构造方法的第一行,如果不写,第一行根本没有默认的this()语句

 b.super关键字

    1.super关键字:

     a.我们可以使用 super.成员变量/super.成员方法 来使用父类的非private修饰的成员变量和成员方法

       当子类的成员和父类的成员重名的时候,我们用super调用父类的成员

    2.super(参数)//super语句:

     a.super(参数)会自动调用父类的构造方法,调用父类哪个构造方法还是由传递的参数决定

     b.super(参数)语句一定也是放在构造方法第一行,如果不写,第一行会自动添加super()语句

       如果第一行已经写了this(参数)语句,super(参数)语句不再添加,虽然第一行写了this(参数)

       会调用其它的构造方法,但是该构造方法依然要走父类的构造方法

3.综合案例:

 public class Person {
     private String name;
     private String sex;
     public Person(String name,String sex){
         this.name=name;
         this.sex=sex;
     }
     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getSex() {
         return sex;
     }

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

 }

 public class Student extends Person {
     private String sno;//学生编号
       
     //具有姓名,性别,学号参数的构造器
     public Student(String name,String sex,String sno){
          super(name,sex);//将共有的属性交给父类来初始化
                          //而子类特有的属性自己初始化
          this.sno=sno;//儿子自己的初始化动作
     }
     public Student(String name,String sex){
         this(name,sex,"默认:110");//name,sex不再由Student(String name,String sex)来初始化
                               //而交给它的兄弟public Student(String name,String sex,String sno)来初始化
     }                        //this("江旻(min)","LitteLitteBoy","默认:110")
     
     
      
     
     public String getSno() {
         return sno;
     }


     public void setSno(String sno) {
         this.sno = sno;
     }
     public String getStuInfo(){
         return super.getName()+".."+super.getSex()+".."+this.sno;
     }
     
 }

 public class Demo {
     public static void main(String[] args) {
        Student s=new Student("山山","LittleBoy","201310101");//学生一有就
                                                  //让它具有姓名,性别,学号
        System.out.println(s.getName()+"..."+s.getSex()+"..."+s.getSno());//前两个getXX方法都是Student从父类继承下来的
           Student s2=new Student("江旻(min)","LittleLittleBoy");//学生一有就
           //让它具有姓名,性别,学号
            System.out.println(s2.getName()+"..."+s2.getSex()+"..."+s2.getSno());//前两个getXX方法都是Student从父类继承下来的
           System.out.println(s2.getStuInfo());
     
     }
 }