Core Java(五)

类和对象&方法

——类的定义

现实世界的事物

属性：人的身高，体重等

行为：人可以学习，吃饭等

Java中用class描述事物也是如此

成员变量：就是事物的属性

成员方法：就是事物的行为

        定义类其实就是定义类的成员(成员变量和成员方法)

 

——this

代表所在类的对象引用

       记住：方法被哪个对象调用，this就代表那个对象

——什么时候使用this呢?

现阶段，局部变量隐藏成员变量；

其他用法后面和super一起讲解

——封装
   隐藏对象属性和实现细节，仅对外提供公共访问方式

成员变量用private修饰，提供get/set方法
   public void setNumber(int number){
        this.number = number;
   }
   public int getNumber(){
        return number;
   }

——封装原则：

将不需要对外提供的内容都隐藏起来；

把属性隐藏，提供公共方法对其访问；

——private

 是一个权限修饰符。

        可以修饰成员(成员变量和成员方法)

        被private修饰的成员只在本类中才能访问。

——private最常见的应用

把成员变量用private修饰，提供对应的getXxx()/setXxx()方法

——构造器（构造方法）

创建对象时使用的一个特殊的方法

——构造方法格式

方法名与类名相同；

没有返回值类型，连void都没有；

——构造方法注意事项

如果你不提供构造方法，系统会给出默认构造方法；

如果你提供了构造方法，系统将不再提供；

构造方法也是可以重载的；

如果在构造方法中使用this，那么this必须放在第一句；

虽然构造方法没有返回值，但是也可以写一个return，在最后写return;这种做法在任何void类型的方法最后都是没有问题的。

——继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

——Java中如何实现继承

　   　通过extends关键字可以实现类与类的继承

　　  　 class 子类名 extends 父类名 {} 

              单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

——使用继承的利弊

——继承的好处

提高了代码的复用性

多个类相同的成员可以放到同一个类中

提高了代码的维护性

如果功能的代码需要修改，修改一处即可

让类与类之间产生了关系，是多态的前提

——继承的弊端

让类与类之间产生了关系，是多态的前提

其实这也是继承的一个弊端：类的耦合性很强

设计原则：高内聚低耦合。

简单的理解：内聚就是自己完成某件事情的能力；耦合就是类与类之间的关系。

我们在设计的时候原则是：自己能完成的就不麻烦别人，这样将来别人产生了修改，就对我的影响较小。由此可见：在开发中使用继承其实是在使用一把双刃剑。

——继承的特点

                     ——Java只支持单继承，不支持多继承。

一个类只能有一个父类，不可以有多个父类。

class SubDemo extends Demo{} //ok

class SubDemo extends Demo1,Demo2...//error

——Java支持多层继承(继承体系)

class A{}

class B extends A{}

class C extends B{}

——继承中的注意事项

子类只能继承父类所有非私有的成员(成员方法和成员变量)；

其实这也体现了继承的另一个弊端：打破了封装性

子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法；

不要为了部分功能而去继承；

              ——super

super的用法和this很像，this代表本类对应的引用；super代表父类存储空间的标识(可以理解为父类引用)

——用法(this和super均可如下使用)：

访问成员变量

this.成员变量 super.成员变量

访问构造方法(马上讲)

this(…) super(…)

访问成员方法(马上讲)

this.成员方法() super.成员方法()

——继承中构造方法的关系

                    子类中所有的构造方法默认都会访问父类中空参数的构造方法；

                    为什么呢？

如何父类中没有构造方法，该怎么办呢?

——继承中成员方法的关系

首先在子类中找

然后在父类中找

如果还是没有就报错。(不考虑父亲的父亲…)

              ——方法重写

                    子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。

——使用特点

如果方法名不同，就调用对应的方法；

如果方法名相同，最终使用的是子类自己的；

——方法重写的应用

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

——方法重写的注意事项

父类中私有方法不能被重写；

子类重写父类方法时，访问权限不能更低；

父类静态方法，子类也必须通过静态方法进行重写；

——多态

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承是为了重用父类代码。两个类若存在is-a的关系就可以使用继承。

面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。

 多态指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

        多种形态

        同种事物，在不同境况下的不同的体现方式

　　    Animal a = new Dog();
 　　   Animal b = new Cat();

 ——多态存在的三个必要条件

                 要有继承关系；

                 要有方法重写；                          

                 要有父类引用指向子类对象；

——成员访问特点

成员变量：编译看左边，运行看左边

成员方法：编译看左边，运行看右边

静态方法：编译看左边，运行看左边

——多态的好处和弊端

——好处

 提高了程序的维护性(由继承保证)

                       提高了程序的扩展性(由多态保证)

                       接口性

——弊端

不能访问子类特有功能

——多态中的转型问题

——向上转型

从子到父：父类引用指向子类对象

——向下转型

从父到子：父类引用转为子类对象（强制类型转换）

向上转型：
    Fu fu = new Zi();
    向下转型:
    Zi zi = (Zi)fu();

Animal a1 = new Dog();
    useAnimal(a1);
    Dog d = (Dog)a1;
    d.lookDoor();

方法

——方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

 ——方法重载特点

                与返回值类型无关，只看方法名和参数列表

                在调用时，虚拟机通过参数列表的不同来区分同名方法

 

——Java方法参数的传递方式

java中只有值传递

——值传递

方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参 数的值。

——引用传递

也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。

——Java中的不定长参数

如果一个方法的参数定为不定参数的话，这个参数可以根据参数个数动态生成一个数组，然后传入方法执行。

不过，不定参数有两个规定：第一，方法的参数列表中最多只有一个不定长度的参数；第二，就是不定长度的数组的位置必须是最后一个参数。不然不能通过编译。

对于第一个规定，是因为如果有多于一个不定长度的参数，当真正调用这个方法的时候，JVM、将不知道前面的不定长度参数有多长, 下一个参数是从哪里开始.

对于第二个参数也是一样，编译器不知道不定长度参数的长度，无法确定从哪里开始下一个参数。

——知识点补充

——为什么main方法中会有形参——String[] args？

其实main方法中的形参是可以删掉的，这么写从语法层面也不会报错，它提供给我们一个数组参数可以让程序每次运行由参数配置，具有一定的动态性。

——增强for循环

For-Each循环也叫增强型的for循环，或者叫foreach循环。

　　         For-Each循环是JDK5.0的新特性（其他新特性比如泛型、自动装箱等）。

　         　For-Each循环的加入简化了集合的遍历。

其语法如下：

　　for(type element: array)

　　{

      　　System.out.println(element);

　　}

 for-Each循环的缺点：丢掉了索引信息。

　　       当遍历集合或数组时，如果需要访问集合或数组的下标，那么最好使用旧式的方式来实现循环或遍历，而不要使用增强的for循环，因为它丢失了下标信息。