Java面向对象

1.什么是面向对象?

         面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。

2.什么是对象？

　　对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

　　类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

　　当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

3.什么是类？

　　类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。

　　Java中的类实现包括两个部分：类声明和类体。

4.面向对象的特性

面向对象的特征：

• 封装(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();//打印结果将会是什么？　　}　　}