黑马程序员 ——面向对象

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

面向对象

在Java中，高手们的概念就是万物皆对象。

面向对象的概念：

面向对象：是基于面向过程的一种思想。

面向过程：强调的是功能行为。

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

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

例如：开门

我们想开门，就是在指挥门的打开功能。

具体开门的动作是门自动完成的，具体门是怎么完成开门动作的，我们不管。因为它具备打开的功能，我们想开门，只要调用它的打开功能，只要结果。

例2：服务员

当我们去饭管吃饭的时候，我们要叫服务员点餐，我们只要说出菜的名称，服务员就把菜单拿给厨师去做，厨师就具备炒菜的功能，炒完后我们只要看这菜能吃，就行。

我们想吃这个菜就是过程。具体怎么做出来的就是过程。

面向对象和面向过程：

                                           图例：

面向对象有三个特征：封装，继承，多态

以后的开发过程：其实就是找对象用。没有对象，就创建一个对象。

找对象，建立对象，使用对象，并维护对象的关系。

类与对象的关系

类：就是对现实生活中事物的描述。

对象：就是这类事物，实实在在存在的个体。

想要描述：提取对象中共性内容。对具体的抽象。

映射到Java中描述就是class定义的类。

具体对象就是对应Java在堆内存中用new建立实体。

例子：

需求：描述小汽车。描述事物其实就是在描述事情的属性和行为。

分析：

1、属性：轮胎数。颜色。

2、行为： 运行。

定义类其实就是在定义类中的成员。（成员：成员变量<-->属性，成员函数<-->行为。）

属性对应是类中变量，行为对应的类中函数或方法。

其实定义类，就是在描述事物，就是在定义属性和方法，属性和行为共同成为类中的成员（成员变量和成员方法）。

类中不必有主函数，不必保证独立运行,只有保证有一个主函数入口调用类就行。

成员变量和局部变量的区别。

作用范围。

成员变量作用于整个类中。

局部变量变量作用于函数中，或者语句中。

在内存中的位置：

成员变量：在堆内存中，因为对象的存在，才在内存中存在。

局部变量：存在栈内存中。

*/

 

成员变量：

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

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

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

 

局部变量：

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

• 局部变量存在于栈内存中。

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

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

面向对象在内存中的结构

public class _02Car对象 {public static void main(String[] args) {//生产汽车就是在Java中通过new操作符来完成//其实就是在堆内存中产生一个实体Car c = new Car();c.color="Blue";c.run();}}//创建对象class Car{//定义成员变量String color = "red";int num = 4;//定义对象方法void run(){System.out.print("车是"+color+"色的，有"+num+"个车胎");}}

匿名对象，没有名字的对象 。

new Car();//匿名对象。其实就是对象的简写格式。

1、当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

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

注意:调用匿名对象的属性是没有意义。

封装

封装：是指隐藏对象的属性和实现细节，仅对外提供 公共访问方式。

好处：
• 将变化隔离。
• 便于使用。
• 提高重用性。
• 提高安全性。

封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性都隐藏，提供公共方法对其访问。

举例：键盘：

我们只要会使用键盘上的键，敲出我们需要的  文字  就可以了，至于键盘里面是什么构造，怎么实现我们敲出字来，这个我们就不用思考了，

简称：封装

private(私有)关键字

 private关键字：

• 是一个权限修饰符。

• 用于修饰成员(成员变量和成员函数)

• 被私有化的成员只在本类中有效。

 常用之一：

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

Ｐriva解析图

/* * Private：私有权限修饰符。用于修饰类中的成员（成员变量，成员函数） * 私有只在本类中有效 *  * 将age成员私有化后，类以外即使建立了对象，也不能直接访问 * 但人该有年龄，就需要在Person类中提供对应访问的age变量 *  * 注意：私有仅仅是封装的一种表现形式 *       之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断语句，对访问数据操作 *       提高代码的健壮性。 */class Person{//年龄private int age;//私有变量//赋值public void setAge(int x)//setAge没有返回值，而且要进行传参{if(x>0 && x<130){age = x;Speak();//判断成功，输出}else{System.out.print("输入有误，重新输入！"); }}//取值public int getAge(){return age;}//人的语言功能void Speak(){System.out.print("我今年"+age+"岁了");}}public class _04封装Private {public static void main(String[] args){Person p = new Person();p.setAge(222);//传值}}

构造函数：

构造函数特点：

1、 函数名与类名相同。

2、不用定义返回值类型。

3、没有具体的返回值。

构造函数：构建创造对象时调用的函数。

构造函数作用：给对象进行初始化。

创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

注意：

1、 默认构造函数的特点。

2、多个构造函数是以重载的形式在在的。

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，给对象进行默认初始化。

一般函数：对象创建后，需要函数功能时才调用。(函数只有被调用才执行)

构造函数：对象创建时，只调用一次。

一般函数：对象创建后，可以被调用多次。

什么时候定义构造函数呢？

在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。

构造函数可以有多个，用于对不同的对象进行针对性的初始化。

多个构造函数在类中是以重载的形式来体现的。

构造函数的小细节：

当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数Person(){}

当在类中自定义了构造函数后，默认的构造函数就没有了

//下面定义“构造函数”class PersonOne{//定义私有成员变量private String name;private int age;//定义构造函数PersonOne()            //始初化函数{System.out.println("姓名="+name+",年龄="+age);}PersonOne(String a){name = a;System.out.println("姓名="+name+",年龄="+age);Say();//调用功能}//Get Set 什么时候用？例如：想改孩子出生时的名字时public void setName(String x){name = x;}public String getName()//这个带返回值{return name;}PersonOne(String a,int b){name = a;age = b;System.out.println("姓名="+name+",年龄="+age);Say();//调用功能}//下面定义功能void Say(){System.out.println("cry");}}public class _05面向对象_构造函数 {public static void main(String[] args){PersonOne p1 = new PersonOne();PersonOne p2 = new PersonOne("张三");PersonOne p3 = new PersonOne("李四",22);}}

this：关键字

特点：this代表其所在函数所属对象的引用。

换言之：this代本类对象的引用。

什么时候使用this关键字呢？

当在函数内需要用到调用该函数的对象时，就用this。

当成员变量和局部变量重名，可以用关键字this来区分。

this：代表对象。代表哪个对象呢？当前对象。

this：就是所在函数所属对象的引用。

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

/* * this 它所在函数所属对象的引用 * 白话说：哪个函数在调用this所在的函数，this就代表哪个对象 */class PersonThree{private String name;private int age;PersonThree(){System.out.println("名字："+this.name+"，年龄是："+this.age);}PersonThree(String name){this.name = name;System.out.println("名字："+this.name+"，年龄是："+this.age);}PersonThree(String name,int age){this.name = name;this.age = age;System.out.println("名字："+this.name+"，年龄是："+this.age);this.Say();//也可以加this}public void setName(String name){this.name = name;}public String getName(){return name;}public void Say(){System.out.print("说话功能");}}public class _07this关键字 {public static void main(String[] args){PersonThree p = new PersonThree("zhangsan");PersonThree p1 = new PersonThree("lisi",22);}}

this在构造函数中的应用

/* * this语句   用于构造函数之间，相互调用 * this语句只能定义在构造函数的第一行，因为初始化要先执行。 */class PersonFor{private String name;private int age;PersonFor(){this("haha");}PersonFor(String name){this.name=name;}PersonFor(String name,int age){this(name);this.age=age;}void print(){System.out.println("名字："+name+"年龄："+age);}}public class _08this在构造函数中的调用 {public static void main(String[] args){PersonFor p1 = new PersonFor();PersonFor p2 = new PersonFor("张三",22);p1.print();p2.print();}}

静态Static

静态Static 什么时候使用？/*静态修饰的内容可以被对象共享。静态的好处？可以节省内存空间，不用每个对象都去创建一份相同的引用。例如：国家。 * 什么时候使用静态？ *  * 要从两方面下手： * 因为静态修饰的内容有成员变量和函数。 * 什么时候定义静态变量呢？ * 当对象中出现共享数据时，（例如：同属一个国家：中国）该数据被静态所修饰。 * 对象中特有的数据要定义成非静态存在于堆内存中。 *  * 什么时候定义静态函数呢？ * 当功能内部没有访问到非静态数据时，（对象的特有数据） * 那么该功能可以定义成静态的。 */class Person{String name;//直接调用方法功能public static void Show(){System.out.println("haha");}}public class _03静态Static什么时候用 {public static void main(String[]args){//创建对象的方式   调用方法Person P = new Person();P.Show();//不创建对象的方式调用Person.Show();//无需new一个对象，直接调用静态方法功能（这样可以节省内存）}}

静态代码块

/* * 静态代码块：格式 * static * { * 静态代码块的执行语句 * } *  * 静态代码块特点：随着类的加载而加载。只执行一次。（并优先于主函数执行） * 白话是：程序一执行起来，先对静态代码块执行，所有的静态代码块执行完成后，再执行主函数 * 对类进行初始化。 */class StaticCode{/*小知识点：int num=9;static{System.out.println("后面不能加gum，因为静态成员只能访问静态变量！"+num);}*/static{System.out.println("a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行");}{System.out.println("e..构造代码块，给对象初始化的。");}StaticCode(int x){System.out.println("f..构造函数，给对应对象初始化的");}                 //这个后面可以加上面的num;因为它是对象的初始化，所以可以访问成员变量}public class _05静态代码块 {static {System.out.println("b..对类进行初始化。");}public static void main(String[]args){///new StaticCode();//new StaticCode();   //new两个对象，但在程序中只执行了一次。new StaticCode(4);//进行传递参数System.out.println("over");}static{System.out.println("c");}}/* * 上面代码的执行顺序是： *b..对类进行初始化。ca.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行e..构造代码块，给对象初始化的。f..构造函数，给对应对象初始化的over */

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------