黑马程序员---面向对象

面向对象是相对面向过程而言的，无论面向对象还是面向过程，都是一种思想，并无级别之分。

面向过程：

                 强调的是功能。

面向对象：

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

                面向对象是基于面向过程的。

类和对象的关系：

                             对象是类具体存在的实例！

</pre><pre name="code" class="java">public class Student{
   private String nama;
<pre name="code" class="java">   private int age;
public String setName(String name){
   this.name=name;
}
public int setAge(int age){
   this.age=age;
}

public void getName(){
   return name;
}

public void getAge(){
return age;
}
}


//学生是一个类，而每一个学生则是学生这个类的每一个具体存在的对象
public class StudentTest(){
public static void main(String[] args){
Student st = new Student();//拿到Student的实例，可以通过实例调用Student类中的方法
st.setName("张三");
System.out.println(st.getName());
}
}

面向对象三大特征：

1.封装

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

            好处：

                     将变化隔离；

                     便于使用；

                     提高重用性；

                     提高安全性；

             封装的原则：

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

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

如：

public class Student{
 private String name;//将属性私有化，隐藏起来不让外界直接访问属性，提高了安全性
<pre name="code" class="java"><pre name="code" class="java"> private int age;
public String setName(String name){ //提供公共访问方式
   this.name=name;
}
public int setAge(int age){
   this.age=age;
}

public void getName(){
   return name;
}

public void getAge(){
return age;
}

//java API 那么多的类，无需知道别人是怎么实现的，怎么写的，别人封装好了，值需拿来用就行了！
}

 2.继承

            继承的好处在于，重用父类的代码和数据，而子类不需要重头写起。

            被继承的类叫基类，也称父类，超类。

            继承类叫子类，也称派生类。

            一个类要继承另一个类，通过使用extends关键字实现继承关系。

如：                          

public class A{
 public void show(){System.out.println("大家好！"); 
 }
}

public class B extends A{
 public static void main(String[] args){
  show();//可以直接调用父类的方法，以及其他未被private 修饰符修饰的所以成员
 }
}

Java只支持单继承，其实在接口技术中，Java 是可以多继承的。

3.多态

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

如：猫类    狗类     动物类

        动物类  动物 =  new 猫（）；

        动物类  动物 =  new 狗（）；

        多态不光体现在对象上，方法上也有体现

        重载，和覆盖就是多态的体现，在父类中有一个，子类中也有一个

static 关键字，用于修饰成员，变量和方法。

        1.被static 修饰后的成员具备的特点：

                                 1.随着类的加载而加载，也会随着类的消失而消失，生命周期最长。

                                 2.优先于对象存在，静态是先存在，对象是后存在。

                                 3.被所有的对象共享，可以直接使用类名调用也可以使用对象调用。

        2.使用static关键字需注意：

                                 静态方法只能访问静态成员，静态优先于对象，所以静态方法中不可以使用this、super 关键字，主函数是静态的。

                                 非静态方法即可以访问静态，也可以访问非静态。

        3.实例变量和类变量的区别：

                                 1.存放的位置

                                     类变量随着类的加载而加载，存在方法区中。

                                     实例变量随着对象的建立而存在堆内存中。

                                 2.生命周期

                                    类变量生命周期最长，随着类的消失而消失。

                                    实例变量生命周期，随着对象的消失而消失。

        4.静态的利与弊：

                                 利：对对象的共享数据进行单独空间的存储，节省空间，可以直接被类名调用。

                                 弊：生命周期过长，访问出现局限性，只能访问静态。