Java面向对象

面向对象是一种程序设计方法，或者是程序设计规范，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。 面向对象是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者

完成需求时：

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

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

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

面向对象的开发过程其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程其实就是在管理和维护对象之间的关系。

面向对象的特征：

? 封装(encapsulation)

? 继承(inheritance)

? 多态(polymorphism)

1.封装

概念:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：? 将变化隔离。? 便于使用。? 提高重用性。? 提高安全性。

封装原则：

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

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

Java中可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

• private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
• default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
• protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
• public：类中限定为public的成员，可以被所有的类访问。

 如下面的这个student类，就是使用了封装，将类中的属性name 、age和score私有化，使外部不能直接访问他们，只能通过public类型的对他们方法进行操作。

class Student {

private   String name;//声明属性 ,并设为私有类型，起到封装的作用

private   int age;

private   int score;

       public Student(String name,int age ,int score) { //构造函数，分别给name、age、score赋值

              this.name= name;// ：this代本类对象的引用

              this.age= age;

              this.score= score;

       }

       public String getName() { //设置getter方法，因为变量设为了私有，对象无法访问类中的属性，需要用getter方法获取变量

              return name;

       }

       public void setName(String name) { //设置setter方法，因为变量设为了私有，对象无法访问类中的属性，需要用setter方法给变量赋值

              this.name = name;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public int getScorre() {

              return score;

       }

       public void setScorre(int score) {

              this.score = score;

       }

}

 

2.继承

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。

新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

子类可以直接访问父类中的非私有的属性和行为。通过 extends 关键字让类与类之间产生继承关系。如下：class SubDemo extends Demo{} 

继承提高了代码的复用性。

继承的出现让类与类之间产生了关系，提供了多态的前提

继承的特点：

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

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

? class SubDemo extends Demo{} //这是对的

? class SubDemo extends Demo1,Demo2...//这是错的

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

? class A{}

? class B extends A{}

? class C extends B{}

 定义继承需要注意：

? 不要仅为了获取其他类中某个功能而去继承

? 类与类之间要有所属关系，xx1是xx2的一种。

如：

class Ren { //父类

       int age=20;

       String name="wk";

Super.sho

       public void show() {

              System.out.println("姓名："+name+"   年龄:"+age);

             

       }

        }

 

class Sudents extends Ren {//子类Sudents继承了父类Ren

       int score=90;//增加了新的属性

int age= super.age+1;//使用super标记父类中的元素，修改了Ren中age的值

       public void show() {//重写了父类中的方法（  覆盖时，子类方法权限一定要大于等于父类方法权限，静态只能覆盖静态。）

 

                     System.out.println("姓名："+name+"   年龄:"+age+"   分数:"+ score);// Sudents继承了Ren，所以Ren中的属性name和age在Sudents可以直接使用

       }

 

}

 

 

public class Preson {

        public static void main(String[] args) {

                  Ren ren = new Ren();//声明一个Ren对象

                     Sudents sudents  = new Sudents();//声明一个Sudents对象

ren.show();

                     sudents.show();

       }

      

        }

程序运行结果是：

super和this的用法相同：this代表本类应用 ；super代表父类引用 。当子父类出现同名成员时，可以用super进行区分 ，子类要调用父类构造函数时，可以使用super语句。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

注意： 

1. 子类中所有的构造函数默认都会访问父类中空参数的构造函数，因为每一个构造函数的第一行都有一条默认的语句 super();子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。当父类中没有空参数的构造函数时，子类的构造函数 必须通过this或者super语句指定要访问的构造函数。

2. 覆盖时，子类方法权限一定要大于等于父类方法权限

静态只能覆盖静态。

父类中的私有方法不可以被覆盖。

3．被final修饰的类是一个最终类，不可以被继承。 

被final修饰的方法是一个最终方法，不可以被覆盖。

被final修饰的变量是一个常量，只能赋值一次

内部类只能访问被final修饰的局部变量。

4. 继承与重载：一是子类与父类的关系，二是重载方法的调用问题。

3.多态

方法的重写、重载与动态连接构成多态性。Java只允许单继承，这样做虽然保证了继承关系的简单明了，但是功能上有很大的限制，所以，Java引入了多态性的概念。此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

多态性：发送消息给某个对象，让该对象自行决定响应何种行为。

　　通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

　　java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

　　1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。

　　2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。

要理解多态性，首先要知道什么是“向上转型”。

子类Cat继承了Animal类，那么后者就是前者是父类。

　　Cat c = new Cat();//实例化一个Cat的对象，

　　    Animal a = new Cat();//定义了一个Animal类型的引用，指向新建的Cat类型的对象

　 由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做的什么意义是：因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，

　　定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

　　所以，父类类型的引用可以调用父类中定义的所有属性和方法，但是对于子类中定义而父类中没有的方法，它是无可奈何的；

　　同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

　　对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

　　如这段程序：

　class Father{

　　public void func1(){

　　func2();

　　}
　　　　

　　public void func2(){//这是父类中的func2()方法，因为下面的子类中重写了该方法

//所以在父类类型的引用中调用时，这个方法将不再有效

//取而代之的是将调用子类中重写的func2()方法

　　System.out.println("AAA");

　　}

　　}

　　class Child extends Father{

　　//func1(int i)是对func1()方法的一个重载

　　//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用

　　//所以在下面的main方法中child.func1(68)是不对的

　　public void func1(int i){

　　System.out.println("BBB");

　　}

　　//func2()重写了父类Father中的func2()方法

　　//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法

　　public void func2(){

　　System.out.println("CCC");

　　}

　　}
　　public class PolymorphismTest {

　　public static void main(String[] args) {

　　Father child = new Child();

　　child.func1();//打印结果将会是什么？

　　}

　　}

　　这是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

　所以程序运行结果应该是“CCC”。

实现多态，有二种方式，覆盖（override），重载（overload）。 

覆盖，是指子类重新定义父类的虚函数的做法。它是覆盖了一个方法并且对其重写，以求达到不同的作用。在覆盖要注意以下的几点： 
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果； 
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致； 
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类； 
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。 

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，在使用重载要注意以下的几点： 
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）； 
2、不能通过访问权限、返回类型、抛出的异常进行重载； 
3、方法的异常类型和数目不会对重载造成影响； 
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

多态也有弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)