黑马程序员——Java基础---面向对象

---------- android培训 、 java培训 、期待与您交流！ ----------

一、理解 

(1)面向对象：是基于面向过程的一种思想。
       面向过程：以函数为基础，关注实现过程。

       面向对象：以对象为基础，关注实现结果。

举例：

面向过程就好比洗衣服,你先放洗衣粉, 再放水,再搓,换水等一系列的操作,而面向对象以对象为基础,

它强调的是这个对象可以完成什么功能,

在洗衣服这件事情上,就容易多,调用这个洗衣机这个对象就可以帮我完成,

这就是面向对象。

(2)面向对象的思想特点：

 A:是一种更符合人们思考习惯的思想。

 B:把复杂的事情简单化了。
 C:把我们从执行者变成了指挥者。

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

 (3)面向对象的三个特征：

        封装（encapsulation）   继承（inheritance）   多态（polymorphism） 

 (1)封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。(加密的数据库,文档案,我们不能直接访问,只能通过公共的访问方式(数据库的工作人员或者说账号密码.)

 好处：

A:隐藏实现细节，提供公共的访问方式

B:提高代码的复用性

C:提高代码的安全性

D:便于使用

F:将变化隔离

 (2)继 承（面向对象特征之一）

      把多个类中相同的内容给提取出来定义到一个类中

      举例（生孩子，父亲有的，儿子也有，有点像遗传的味道）

 好处： 

1：提高了代码的复用性。 

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

 父类的由来：其实是由多个类不断向上抽取共性内容而来的

 特点：

java的类只支持单继承，不支持多继承 

（多继承，调用不明确）

支持多层继承（继承体系）

(3)多态

什么叫多态:（角色扮演）

多态意味着一个对象有着多种形态，可以在特定的情况下，表现不同的状态，从而对应不同

属性和方法，简单的说，多态就是使用父类类型的变量引用子类对象，根据被引用子类对象的特征，

程序会得到不同的运行效果

前提：

A:要有继承关系（或者实现关系）

B:要有方法重写（子类重写父类的方法）

C:要有父类引用指向子类对象

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。 

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，

不可以访问 子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性) 

多态的前提： 1：必须要有关系，比如继承、或者实现。 2：通常会有覆盖操作。

二、类与对象

1、类与对象的关系

类的定义：

       使用计算机语言就是不断的描述现实生活中的事物，而java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

       生活当中描述事物无非就是描述事物的属性和行为。如：人的身高，体重等属性；讲话跑步等行为。Java则是用类class来描述对象的属性和行为。定义类其实就是在定义类中的成员（成员变量和成员函数）。

       属性：对应类中的成员变量。

       行为：对应类中的成员函数。   

而对象即是该类事物实实在在存在的个体。

2、成员变量和局部变量

       之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实它两都是变量，规范写法上也没啥区别，都是标识符，但是在作用范围和内存中分配不同。

区别：

       成员变量：

                a)成员变量定义在类中，在整个类中都可以被访问。

                b) 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

                c) 成员变量有默认初始化值。

       局部变量：

                a) 局部变量只定义在局部范围内，如：函数内，语句内等。

                b) 局部变量存在于栈内存中。

                c) 作用的范围结束，变量空间会自动释放。

                d) 局部变量没有默认初始化值。

3、匿名对象

       匿名对象是对象的简化形式。

       匿名对象两种使用情况

                1、当对对象方法仅进行一次调用的时。

                2、匿名对象可以作为实际参数进行传递。

例： new Car();

注：如果对一个对象进行多个成员调用，必须给这个对象起个名字。

 

三、对象的封装

1、 概念

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

2、 好处

        a）将变化隔离。

        b）便于使用。

        c）提高重用性。

        d）调高安全性。

3、 原则

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

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

4、 封装的表现形式之一——private（私有）

        private关键字：权限修饰符；用于修饰类中的成员（成员变量，成员函数）；私有只在本类中有效。

       常用之一：

                将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

        如：我有一个人对象，而年龄这一属性我不想被对象访问，我就可以将其设为private。

封装和private的应用：

A:把成员变量用private修饰

B:提供对应的getXxx()和setXxx()方法

如下实例：人物对象程序view plaincopy

class PersonDemo    {  
	public static void  main(String[] args)  {  
		Person P = new Person();//创建人物对象  
		P.setAge(160);//调用年龄方法  
		P.getAge();
		P.speak();  
	}  
}
class Person{ //人对象的类   
    private int age;//人对象的年龄属性  
    
    public Person() {
		super();
	}
	public void setAge(int a) {   //提供访问方法 
    	//判断是否有效
        if(a>0 && a<130)  {  
            age = a;  
            speak();  
        }  
        else {  
            System.out.println("非法年龄");  
        }
    }   
    public int getAge()//提供获取方法  
    {  
        return age;  
    }  
    public void speak()//对象的说功能  
    {  
        System.out.println("我今年"+age+"岁");  
    }  
}  

四、构造函数

1、 特点：

        a） 函数名与类名相同。

        b） 不用定义返回值类型。

        c） 不可以写return语句。

class Person{     
    private int age;   
    public Person() {   //无参构造
		super();
	} 
	public Person(int age) {  //带参构造
		super();
		this.age = age;
	}
}

2、 作用：

        给对象进行初始化。

3、构造函数的小细节：

        当一个类中没有定义构造函数时，那么系统就会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

4、构造函数和一般函数在写法上有不同。

在运行上也有不同：

        构造函数式在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。

5、什么时候定义构造函数？

        当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

6、构造代码块

       作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数运行。

和构造函数的区别：

       构造代码块是给所以对象进行初始化。

       而构造函数是给对应的对象初始化。

构造代码块中定义的是不同对象共性的初始化内容。

 

五、this关键字

class ThisDemo {
	  public static void  main(String[] args){
		  //创建对象
		  Person p=new Person("张三",34);
		  //调用方法
		  p.speak();
	  }
}
class Person  {  
    private String name;  //上面说到的私有化private修饰
    private int age;  
    
    Person(String name,int age)  //构造方法
    {  
        this.name = name;  //这里用this表示调用构造方法的对象
        this.age = age;  
    }  
    public void speak()  
    {  
        System.out.println("我叫"+name+"...今年"+age+"岁");  
    }   
} 

 以上程序综合了构造函数和this的用法。看上去，是用于区分局部变量与成员变量同名情况。

       this代表它所在函数所属对象的引用。

       简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

this的应用：

       当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

       但凡本类功能内部使用到了本类对象，都用this表示。

this语句：

       用于构造函数之间进行互相调用。如：this(name);

        thi语句只能定义在构造函数的第一行。因为初始化要先执行。

对this的概括总结：

        this的两种用法：1、用于区分同名变量的情况，说的成员和局部同名的时候；2、用于构造函数间调用。

注：一般函数不能直接调用构造函数，因为this语句不能用在一般函数中，只能用在构造函数间。

 

六、static关键字

        static是一个修饰符，用于修饰成员（成员变量和成员函数）。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。格式：类名.静态成员。

static特点：

        1、随着类的加载而加载。

              也就是说：静态会随着类的消失而消失，说明它的生命周期最长。

        2、优先于对象存在。明确一点：静态是先存在。对象是后存在。

        3、被所有对象所共享。

        4、可以直接被类名所调用。

       由于静态成员可以直接被类名调用，因此静态成员变量又称为类变量。而非静态成员变量又被称为实例变量。

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

        1、存放位置。

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

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

        2、生命周期。

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

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

静态有利有弊：

        利处：对对象共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。

        弊端：生命周期过长。

                   访问出现局限性。（静态虽好，只能访问静态）。

静态需要清楚的几个小问题：

什么时候使用静态？

        从两方面下手： 因为静态修饰的内容有成员变量和函数。

1、什么时候定义静态变量（类变量）呢？

        当对象中出现共享数据时，该数据被静态所修饰。

        对象中的特有数据要定义成非静态存在于堆内存中。

2、什么时候定义静态函数呢？

        当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

静态使用注意事项：

        1、静态方法只能访问静态成员。

              非静态方法既可以访问静态也可以访问非静态。

        2、静态方法中不可以定义this，super关键字。

              因为静态优先于对象存在。所以静态方法中不可以出现this。

        3、主函数是静态的。

静态代码块：

       格式：

              static

              {

                           静态代码块中的语句。

              }

特点：随着类的加载而执行，执行一次。并优先于主函数。用于给类进行初始化。

对象的初始化过程：

        定义一个新对象都做了哪些事情？

        1、把类名.class文件加载到内存中。

        2、执行该类中的static代码块，如果有得话，给该类进行初始化。

        3、在堆内存中开辟空间，分配内存地址。给对象

        4、在堆内存中建立对象的特有属性。并进行默认初始化。

        5、对属性进行显示初始化。

        6、对对象进行构造代码块初始化。

        7、对对象进行对应构造函数初始化。

        8、将内存地址赋给栈内存中的对象名变量。

静态的应用——文档说明书。

        每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。