java学习笔记面向对象

一、面向对象概述

面向对象就是一种思想，面向对象是相对面向过程而言。两者都为思想。

面向过程：强调的是功能行为，注重的是过程与过程中的行为（功能）

面向对象：将功能封装进对象，强调具备了功能的对象。

面向对象是基于面向过程的，即面向过程是面向对象的基础。

面向过程的代表语言：Basic、C

面向对象发展于面向过程，发现每个功能都所属于一个（有一个所属关系，故将功能封装）

面向对象将问题简单化了，我们也从过去的执行者，变为指挥者。

编程思想：先确定对象，在确定对象应有的功能，先在Java中寻找有没有相关对象，若没有，自己创造方法对象，封 装功能。

名词提炼法：确定动作有几个对象。

面向对象有三大特征：封装、继承、多态。

以后的开发，其实就是找对象使用，若没有则创建一个对象。

开发的过程：找对象，建对象，用对象，维护对象。

二、类与对象

类：对现实生活中事物的描述。类主要用于描述。描述的内容是属性和行为（变量和方法）

对象：就是现实生活中，实实在在的实体。

类与对象计算Java语言用来描述事物的方式。

类与对象的关系：类是对象的抽象，对象是类的实体（在堆内存中new）

定义类就是描述事物，就是在定义属性和行为。属性和行为共同成为类中成员（成员变量和成员方法）

凡是用于存储多个数据的，我们都称之为实体，都放在堆内存中。

定义对象：就是通过new操作符在堆内存中产生一个实体。

对象的特点在于封装数据。

凡是用于存储多个数据的，我们都称之为实体，都放在堆内存中。

定义对象：就是通过new操作符在堆内存中产生一个实体。

对象的特点在于封装数据。

凡是用于存储多个数据的，我们都称之为实体，都放在堆内存中。

定义对象：就是通过new操作符在堆内存中产生一个实体。

对象的特点在于封装数据。

例：定义一个汽车类，并定义一个类对象：

class Car      // 定义Car类

{   String color = “red”;        // 成员变量车颜色，轮胎数

    int num = 4;

    void run()    // 成员方法

    {   System.out.println(color+”…”+num);   }

}

在主函数中定义对象（main函数中）

Car c = new Car();      // 通过new实例化类

c.color = “blue”;      // 修改对象的color属性

Car c1 = c;        // 新定义对象c1，赋予c的地址

c1.num = 5;        // 定义C1的num值为5

c.run();            // 输出调用成员方法，C，C1指向同一对象

自定义类不需要独立运行，故不需要主函数（但也可以创建main）

成员变量与局部变量作用范围不一样，前者作用于整个类，后者作用于函数中或语句中。成员变量存在堆内存中，局部变量存在栈内存中。

自定义类中有可在本类中实例化对象。

匿名对象调用方法有意义，调用属性无意义。

匿名对象使用方式一：

当对对象的方法只调用一次时，可以用匿名对象来完成，比较简化。若对一个对象进行多次或多个成员变量调用，必须给这个对象起名字。

匿名对象使用方式二：

可以将匿名对象作为实际参数进行传递。

匿名对象是对象的简化形式，定义方式为：new 类名();

情况例：new Car().num = 5;    // 使用完便失效，匿名对象调变量无意义。

               new Car.run();        // 匿名对象调用方法有意义。

main()

{   

        Car c = new Car();   // 主函数中，实例一个Car对象名为c

        show(c);       // 调用方法传参c

c = null;       // 调用完成，清空对象c的指向，堆中数据成垃圾。

show(new Car());    // 匿名对象作实际参数相当于 Car c = new Car();

public static void show(Car c) // 定义一个方法，参数为Car类型。

{

     c.num=3;

     c.color=”black”;    // 改变参数对象的成员变量值

     c.run();          // 调用参数对象的成员方法

}

}

注：匿名类当实际参数时，方法调用结束，堆中数据即成垃圾。

非匿名对象当实参时，只有main函数结束或人工指定，堆中才有垃圾。

三、封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，（封装：Encapsulation）

封装的好处：将变化隔离，便于使用，提高重要性，提高安全性。

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

函数是Java中最小的封装体，类也是封装体，包也是封装。框架

四、修饰符

private：私有修饰符，权限修饰符，用于修饰类中成员（成员变量，成员函数）私有只在本类中有效。

若将变量私有化以后，类以外即便建立了对象也不能直接访问，需要在类中提供对应访问方式。

注：一个成员变量通常对应2个访问方式。1、设置set 2、获取get 。

注：私有仅是封装的一种表现形式，不私有也可以封装。

之所以对外提供访问方式是因为可以控制输入值（访问方式中可以加入逻辑判断等语句，提高代码健壮性。）

注：成员变量在堆内存中有初始值，局部变量在栈内存中无默认值。

eg：class Person    // 自定义类

{   private int age;      // 定义成员变量

    public void setAge(inta)       // 定义成员变量访问方法

    {

       if(a>0&&a<130)

        {

           age = a;     // 判断输入是否非法

           speak();

        }

        elseSystem.out.println(“feifa age”);    // 合理输出

    }

    public int getAge()

    {   return age;  }     // 成员变量访问方法

    void speak()    // 成员方法

    {  System.out.println(“age=”+age);  }

}

class PersonDemo

{   public static voidmain(String[] args)  // 主函

    {   Person p = new Person();      // 实例化类对象

        p.setAge(-40);      // 设置类成员变量，通过访问方法。

    }

}

五、构造函数

构造函数特点：函数名与类名相同，不用定义返回值类型，不可写return语句。

构造函数作用：给对象进行初始化。

注：默认构造函数特点。   2、多个构造函数以重载形式存在。

类对象一建立，就会调用与之对应的构造函数，构造函数的作用是，可用于给对象进行初始化。

当一个类中没有构造函数时，那么系统会默认给该类加入一个空参数的构造函数，当类中自定义了构造函数后，默认的构造函数就没有了。

构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象已建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加对象具备的功能。

一个对象建立，构造函数只运行一次，而一般方法可以被对象调用多次。

什么时候定义构造函数？

当分析事物时，该事物存在具备一些特性或者行为，那么，将这些内容定义在构造函数中。

eg：class Person   // 注：此类无参数构造，不允许定义无参对象。

{   private String name;

    private int age;    // 私有成员变量

    Person(String n)

    {   name = n;

        System.out.println(“ ”);    // 构造函数（有一个参数）

    }

    Person (String name,int a)

    {   name = n; age=a;  

        System.out.println(“ ”);

    }

    public void cry()    // 成员函数

    { System.out.println(“cry”);}

}

class PersonDemo2

{   public static voidmain(String[] args)

    Person p1 = newPerson();      // 无参构造不合法

    Person p1 = new Person(“Lisi”);    // 一个参数实例对象

}

private 是用来修饰成员的，故也可以修饰构造函数，用private修饰的构造是不能生成对象的。

注：若局部变量中有所使用的变量，则系统不会在向外层寻找。此时，若成员变量和局部变量重名引入this关键字。

关键字this，指代本类对象，代表它所在函数，所属对象的引用。简单说，哪个对象在调用this所在的函数，this就代表哪个对象。

this的特点：this指的是调用的对象（指向的同一地址）

this关键字的基本应用

当定义类中函数时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部，使用到了本类对象，都用this表示。

eg：需求：给Person类定义一个用于比较年龄是否相等的函数

   public Boolean compare(Person p)

   {  return this.age = p.age;   }   // this指代调用对象

 

构造函数相互调用，this（相对应参数）

构造函数相互调用，可以更好的实现封装，只公开一个，其他内部调用。构造相互调用的语句必须放在第一个执行语句处，即第一行。

注：死循环调用构造（2个函数相互不停调用）

eg：class Person

   {  private String name;

       Person()

       {}

       Person(String name)

       {  this.name = name;   }

       Person(String name,int age)

       {  this();  this(name);   this.age=age;   }   //构造调用构造

   }

六、继承

继承（extends）：  class 子类 extends 父类（超类、基类）

继承的好处：

  1、提高了代码的复用性。

  2、让类与类之间产生了关系，有这个关系，才有了多态的特性。

注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承，所属关系 is a

Java语言只支持单继承，不支持多继承，因为多继承易带来安全隐患，当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个（优化了c++）但Java保留了多继承机制，并用另一种形式来完成表示（多实现）Java支持多层继承（c extends b，b extends a），也就是一个继承体系

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。

在具体调用时，为什么要创建最子类的对象？

一是因为有可能父类不能创建对象，二是创建子类可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

 

继承代码体现（继承2）

注：this 本类引用，super父类引用。

子父类出现后，类成员的特点：

类中成员：1、变量    2、函数    3、构造函数

1、变量：如果子类中出现非私有的同名成员变量时，子类要访问本类中的同名变量用this。访问父类中的同名变量时用super，super和this的使用方式一致。

子父类中的函数

函数的覆盖（重写），当子类出现和父类一模一样的函数时，当子类调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）

说明：当子类继承父类，沿袭了父类的功能，到子类中。但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没必要定义新功能，儿时使用覆盖的特性，保留父类的功能定义，并重写功能内容。

注：重载只看同名函数的参数列表

重写，自弗雷方法要一模一样（包括返回类型、名称、参数）

eg：class Tel           // 父类

{

    void show()

    {   System.out.println(“number”);  }

}

class NewTel extends Tel

{

  (public)void show()       // 覆盖权限必须大于等于父类 

  {   

      super.show();        // 调用原类方法，在原基础上增加

      System.out.println(“name”);

      System.out.println(“pic”);

   }

}

 

子父类中的构造函数

注：super();   调用父类构造。     this();调用子类构造

在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类中的构造函数默认第一行有一条隐式的语句super();而super();会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();（所有重载构造前都有一个super();）

子类创建对象时一定会先访问父类中的构造函数，若没有无参构造在父类中，则要显式指明要访问哪个有参构造，并给出参数。

为什么子类一定要访问父类中的构造函数？

因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数。

如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注：super语句一定定义在子类构造函数的第一行。

构造函数只this();  和super();   在构造函数中只能出现一个都必须第一行。

结论：子类中所有的构造函数，默认都会访问父类中空参数的构造函数，因为子类每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造时，子类必须手动通过super或者this语句形式来指定要访问的构造函数（父类中的）

当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数，这就是子类的实例化过程。

七、接口

接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象方的，那么该类

可以通过接口的形式来表示。

class用于定义类、interface用于定义接口。

接口定义时，格式特点：

1、接口中常见定义：常量，抽象方法。

2、接口中的成员都有固定修饰符。

   常量：public static final       方法：public abstract

注：接口中的成员都是public的。

interface中的所有成员有固定修饰符，用户不写会默认添上。

类与类是继承关系，类与接口是实现关系（implements）

eg：class 类名 implements 接口名 {   }

接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部都覆盖后，子类才可以实例化，否则子类是一个抽象类。

注：interface编译后，也产生.class文件。接口名调用接口中的常量也可以。

接口可以被类多实现，实现多个接口之间用逗号连接。

类可以在继承类的同时，实现接口，先继承在实现可以扩展类的功能。

接口间的关系是继承。

eg：interface A{}    interface B extends A{}

接口可以多继承（因为无方法体不冲突）

eg：interface A{}    interface B{}    interface C extends B,A{}

 

接口的特点

接口是对外暴露的规则

接口是程序的功能扩展

接口可以用来多实现

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

 

接口用于功能扩展（基本功能定义在类中，扩展功能定义在接口中）

eg：class abstract sporter      // 运动员必备功能定义类中

{   abstract void play();   }

interface Studying        //  运动员扩展功能定义接口

{   void study();   }

class wangwu extends sporter implements Studying

{   void play(){}      public void study(){}    }

 

八、多态

多态：可以理解为事物存在的多种体现形态。

eg：人：男人、女人     动物：猫、狗   eg：猫 x = new 猫(); —>    动物 x = new 猫();

重载和覆盖是函数的多态。

重点了解对象的多态：多态的体现、前提、好处、应用、弊端。

1、多态的体现（提高程序扩展性及复用性）

   父类的引用指向了自己的子类对象，即，父类的引用也可以接收自己的子类对象：

   父类 x = new 子类();

2、多态的前提：

必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提，存在覆盖。

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

4、多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类成员。

5、多态的应用：      6、多态使用的注意事项：

例：abstract class Animal     // 抽象类Animal

{   abstract void eat();   }

class cat extends Animal    // Animal子类 cat

{ 

   public void eat(){   System.out.println(“吃鱼”);   }

   public voidcatchMouse(){   System.out.println(“抓老鼠”);   }

}

class Dog extends Animal    // Animal子类 dog

{ 

   public void eat(){   System.out.println(“吃骨头”);   }

   public void kanJia(){   System.out.println(“看家”);   }

}

class DuoTaiDemo

{ 

   public static voidmain(String[] args)    // 主函数

   {  

       Cat c = new Cat();     // 待验证  

       Animal a = new Cat();

       function(new Cat());

       a.eat();

       c.eat();

   }

   public static voidfunction(Animal a)   // 多态使用

   {   a.eat();  }

}

多态类型转换

eg：Animal a = new Cat();   // 类型提升，向上转换

当使用子类（Cat）特有方法时，如何操作？

Cat c =(Cat) a;     c.catchMouse();     // 强制向下转换。

注：不要出现将父类对象转成子类类型。我们转换的是父类应用指向了自己的子类对象时，该应用可以被提升和强转，多态自始至终都是子类对象在做变化。

eg：Animal a = new Animal();   Cat c = (Cat) a;    // 错误

修改上节的function方法：

publicstatic void function(Animal a)

{

   a.eat();

   if(a instanceof Animal)

   {  System.out.println(“haha”);   }

   else if(a instanceof Cat)

   {   Cat c = (Cat) a;   c.catchMouse();   }

   else if(a instanceof Dog)

   {  Dog d = (Dog) a;  d.Kanjia();   }

}

主函数中：function(new Dog());      function(new Cat());

多态中（父类指向子类对象）成员函数的特点（非静态成员方法）

在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过。如果没有，编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）

在多态中，静态成员函数的特点：无论编译还是运行，都参考左边

（静态无this，super只有类名调用，所以不考虑对象）静态绑定。

九、Object类

Object类是类层次结构的根基，每个类都用Object类作为超类。

Object：是所有对象的直接后者间接父类，传说中的上帝，该类中定义的肯定是所有对象都具备的功能。

equals(objectobj)方法，提示其他某个对象是否与此对象“相等”。（多台表现）

equals方法比较的是地址值，而（==）比的是值。

注：Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没必要重新定义，只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。

Object类方法简介：

toString()方法，返回该对象的字符串表示。

hashCode()方法，返回该对象的哈希值（八进制）

getClass()方法，返回此Object类的运行时类。

getMethods()方法，返回一个包含某些Method对象的数组。

getName()方法，以String的形式返回此Class对象所表达的实体。

说明：toString()——getClass.getName()+’@’+Integer.toHexString(hashCode()).