java面向对象

时间：2016-05-06 15:27:48 阅读：220 评论：0 收藏：0 [点我收藏+]

标签：

面向对象的思想概述：
l程序员从执行者转化成了指挥者。

l完成需求时：

?先去找具有所需功能的对象来用。

?如果该对象不存在，那么创建一个具有所需功能的对象。

?这样简化开发并提高复用。

l类(class)和对象(object)是面向对象的核心概念。

?类是对一类事物描述，是抽象的、概念上的定义

?对象是实际存在的该类事物的每个个体，因而也称实例(instance)。

对象在内存中的图解：
技术分享

成员变量跟局部变量的两个主要的区别：
1.声明的位置的不同：成员变量：声明在类里，方法外
*                          局部变量：声明在方法内，方法的形参部分，代码块内
2 初始化值：成员变量:如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
3 二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中。

对数组操作的几个方法：
    // 数组的反转
   public int[] reverse(int[] arr) {
       for (int x = 0, y = arr.length - 1; x < y; x++, y--) {
           int temp = arr[x];
           arr[x] = arr[y];
           arr[y] = temp;
       }

       return arr;
   }
// 对数组进行排序
   public void sort(int[] arr, String desc) {
       if (desc == "asc") {// ascend:从小到大
           for (int i = 0; i < arr.length - 1; i++) {
               for (int j = 0; j < arr.length - 1 - i; j++) {
                   if (arr[j] > arr[j + 1]) {
                       swap(arr,j,j+1);
                       //swap(arr[j],arr[j + 1]);
                   }
               }
           }
       } else if (desc == "desc") {// 从大到小
           for (int i = 0; i < arr.length - 1; i++) {
               for (int j = 0; j < arr.length - 1 - i; j++) {
                   if (arr[j] < arr[j + 1]) {
                       swap(arr,j,j+1);
                       //swap(arr[j],arr[j + 1]);
                   }
               }
           }
       } else {
           System.out.println("您输入的排序方式有误！");
       }
   }

* 方法的重载（overload）
* 要求：1.同一个类中 2.方法名必须相同 3.方法的参数列表不同（①参数的个数不同②参数类型不同）
* 补充：方法的重载与方法的返回值类型没有关系！

对于方法的可变参数：
/*
* 可变个数的形参的方法：
* 1.格式：对于方法的形参：数据类型 ... 形参名
* 2.可变个数的形参的方法与同名的方法之间构成重载
* 3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
* 4.使用可变多个形参的方法与方法的形参使用数组是一致的。（两个不可以同时存在）
    public void sayHello(String ... args){
       for(int i = 0;i < args.length;i++){
           System.out.println(args[i] + "$");
       }
       //System.out.println("=====");
   }
public void sayHello(String[] args){
       for(int i = 0;i < args.length;i++){
           System.out.println(args[i]);
       }
   }
上述情况，会报错。
用可变参数调用时，可以t.sayHello(new String[]{"hello China","hello BeiJing"});
      也可以 t.sayHello("hello China","hello BeiJing");

* 5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后（可变参数形参只能声明在方法参数的最后）
* 6.在一个方法中，最多声明一个可变个数的形参。

java方法中的参数传递：
* 方法的参数传递（重点、难点）
* 1.形参：方法声明时，方法小括号内的参数
*   实参：调用方法时，实际传入的参数的值
*
* 2.规则：java中的参数传递机制：值传递机制
*   1）形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量
*   2）形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

面向对象的特征一：封装与隐藏
* 问题：当创建了类的对象以后，如果直接通过"对象.属性"的方式对相应的对象属性赋值的话，可能会出现不满足实际
* 情况的意外，我们考虑不让对象来直接作用属性，而是通过"对象.方法"的形式，来控制对象对属性的访问。实际
* 情况中，对属性的要求就可以通过方法来体现。
*
* 解决的方法：（封装性的思想）①将类的属性私有化，②提供公共的方法（setter & getter）来实现调用。
*
* 二、权限修饰符：public private 缺省 protected
*     可以用来修饰属性、方法
*     注：1)权限从大到小排列：public protected 缺省 private
*        2)修饰类的权限有：public 缺省
技术分享

用来限定该类对象对该类成员（成员变量，方法等）的访问权限。

* 一、类的第三个成员：构造器(constructor 构造方法)
* constructor:建造者
* 构造器的作用：①创建对象 ②给创建的对象的属性赋值
*
* 1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器
* 2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。
* 3.如何声明类的构造器。格式：权限修饰符类名(形参){ }
* 4.类的多个构造器之间构成重载
*
*
* 二、类对象的属性赋值的先后顺序：①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化
*                           ④通过"对象.方法"的方式给属性赋值

this关键字：

* 1.可以用来修饰属性、方法、构造器
* 2.this理解为当前对象或当前正在创建的对象.比如：this.name,this.show();（在构造器中使用this表示当前正在创建的对象）
*
* 3.可以在构造器中通过“this(形参)”的方式显示的调用本类中其它重载的指定的构造器。
*   要求：1.在构造器内部必须声明在首行！

* 一、面向对象的特征二：继承性
* 1.为什么要设计继承性？
*
* 2.通过"class A extends B"类实现类的继承。
*   子类：A 父类（或基类 SuperClass）：B
*
* 3.子类继承父类以后，父类中声明的属性、方法，子类就可以获取到。
*    明确：当父类中有私有的属性或方法时，子类同样可以获取得到，只是由于封装性的设计，使得子类不可以直接
*        调用罢了。
*   子类除了通过继承，获取父类的结构之外，还可以定义自己的特有的成分。
*
*   extends：子类是对父类功能的“扩展”，明确子类不是父类的子集。
*
* 4.java中类的继承性只支持单继承：一个类只能继承一个父类。反之，一个父类可以有多个子类。

* 二、方法的重写   ---(方法的重载)     修饰符返回值类型方法名（参数列表）{}
* 1.前提：有子类继承父类
* 2.子类继承父类以后，若父类的方法对子类不适用，那么子类可以对父类的方法重写(override overwrite)、覆盖、覆写。
* 3.重写的规则： 1)要求子类方法的“返回值类型方法名（参数列表）”与父类的方法一样
*               2)子类方法的修饰符不能小于父类方法的修饰符
*               3)*若父类方法抛异常，那么子类方法抛的异常类型不能大于父类的。
*               4)*子父类的方法必须同为static或同为非static的。
                 5）private 方法子类是不可见的，因此也不存在重写。子类中若有个这样的 private 方法，那这个方法与父类中的那个没有任何关系，是完全独立的。

super关键字：

l在Java类中使用super来调用父类中的指定操作：

?super可用于访问父类中定义的属性

?super可用于调用父类中定义的成员方法

?super可用于在子类构造方法中调用父类的构造器

l注意：

?尤其当子父类出现同名成员时，可以用super进行区分

?super的追溯不仅限于直接父类

?super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
（如果父类和子类中有同名的变量，则子类会有两个变量）。

* 3)super修饰构造器：通过在子类中使用“super(形参列表)”来显式的调用父类中指定的构造器。
*    >在构造器内部，“super(形参列表)”必须要声明在首行！
*    >在构造器内部，“this(形参列表)”或“super(形参列表)”只能出现一个！
*    >当构造器中，不显式的调用“this(形参列表)”或“super(形参列表)”其中任何一个，默认调用的是
*      父类空参的构造器！
*    建议：设计一个类时，尽量要提供一个空参的构造器！

l子类中所有的构造器默认都会访问父类中空参数的构造器

l当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行

l如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

（总之：子类对象的创建，一定会调用父类的构造器。）

子类对象实例化的过程：
会首先调用子类对象的所有直接父类和间接父类的构造器，由上到下，依次执行，然后再调用自己的构造器。

* 面向对象的特征三：多态性
* 1.多态性指的是什么？多态性，可以理解为一个事物的多种表型形态。
*   1）方法的重载与重写 2）子类对象的多态性（父类引用指向子类对象）
虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写父类的方法

3.程序运行分为编译状态和运行状态。
*   对于多态性来说，编译时，"看左边"，将此引用变量理解为父类的类型
*   运行时，"看右边",关注于真正对象的实体：子类的对象。那么执行的方法就是子类重写的。
4.子类对象的多态性，并不使用于属性。
父类和子类中有同名的变量，然后父类引用指向子类对象时，引用调用该变量时，是调用的父类的。
（方法子类可以重写或者说是覆盖，所以多态执行子类的方法，但是变量不存在覆盖的情况，子类中会有两个同名的变量，由于是父类的引用，所以调用时，会调用父类的变量。）

java面向对象

标签：

原文地址：http://blog.csdn.net/hangshuai799/article/details/51323624

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行