黑马程序员-Java基础:面向对象(上)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、面向对象概述

      当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每

一步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的

封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

例1-1：洗衣服问题

1).面向过程： 

    准备一盆水和洗衣粉-->将衣服放入盆->.反复搓洗干净->拿出晾。

2).面向对象：

  找到洗衣机->衣服放进洗衣机->拿出晾干。

面向过程思想关注解决问题的具体步骤，即解决这个问题程序员需要做什么； 

面向对象思想关注哪些对象能用于解决这个问题，如果有就调用这个对象，没有就按需求创建这个对象。

1、面向对象的特点

（1）是一种符合人们思考习惯的思想。

（2）可以将复杂的事情简单化。

（3）将程序员从执行者转换成了指挥者。

2、面向对象的特征

（1）封装(encapsulation)

将对象的属性和行为进行封装，其载体为类，类中的东西不需要被使用的人知道，也就是对用户隐藏内部细节，只需要对外提供使用就可以，这就是封装的思想。

封装原则：
       将不需要对外提供的内容都隐藏起来。
       把属性都隐藏，对外提供访问方法。

函数就是Java语言中最小的封装体。封装的好处：提高安全性、提高重用性、将变化隔离、便于使用

private：私有权限修饰符，用于修饰类中成员；私有内容只在本类中有效。
注意：私有仅仅是封装的一种表现形式。

（2）继承(inheritance)

类与类之间有关系，多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。通过extends关键字可以实现类与类的继承，class 子类名 extends 父类名 {}  ，单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

（3）多态(polymorphism）

多态首先是建立在继承的基础上的，先有继承才有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，父类的一个方法在继承的子类中表现出不同的形式。

例：有两款手机，一款能上网，另一款能防水，这两款手机就是手机这个父类的多态，都是手机，但有不同的表现形式。

二、类和对象

1、类和对象概述

类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
例1-2：

我们可以理解图纸就是类，手机就是对象。

类:就是对现实事物的描述.--虚
对象:就是那个事物的实体.--实  

class Phone{//手机类//价格private int price;//牌子private String pingPai;//系统String os;//颜色String color;//大小double daXiao;//像素int xiangShu;public void setPrice(int price){     <span style="white-space:pre"></span> this.price=price;}public int getPrice(){return price;}public void setPingPai(String pingPai){     <span style="white-space:pre"></span> this.pingPai=pingPai;}public String getPingPai(){return pingPai;}//打电话public void call(){System.out.println("打电话~~~");}//玩游戏public void playGame(){System.out.println("打游戏");}//发信息public void sendMessage(){System.out.println("发短信");}//玩apppublic void app(){System.out.println("下载app");}

class PhoneTest {public static void main(String[] args) {    //创建对象Phone p =new Phone();//手机对象//赋值int price=2400;if(price>0){p.setPrice(price);}String brank="小米";       <span style="white-space:pre"></span> p.setPingPai(brank);p.os="安卓";p.color="白色";p.daXiao=5.0;p.xiangShu=800;System.out.println("我的手机：价格"+p.getPrice()+" 品牌"+p.getPingPai()+" 系统是"+p.os+" 颜色"+p.color+" 大小"+p.daXiao+" 像素"+p.xiangShu+"万");//调用方法p.call();p.playGame();p.sendMessage();p.app();}}

2、成员变量和局部变量的区别

a：在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
b：在内存中的位置不同

成员变量 堆内存
局部变量 栈内存
c：生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
d：初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

3、匿名对象

匿名对象是对象的简化形式。
匿名对象两种使用情况
        a：当对对象方法仅进行一次调用的时。
        b：匿名对象可以作为实际参数进行传递。
例： new Car();
注：如果对一个对象进行多个成员调用，必须给这个对象起个名字。

三、封装

1、封装的概述：

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

好处：

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

提高了代码的复用性

提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
2、private关键字

private关键字：

是一个权限修饰符.
可以修饰成员(成员变量和成员方法)

被private修饰的成员只在本类中才能访问。
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用

3、this关键字

this:代表所在类的对象引用
记住：
     方法被哪个对象调用，this就代表那个对象

4、构造方法

（1）构造方法作用概述
给对象的数据进行初始化
（2）构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
（3）构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的

5、类的成员方法

成员方法是类中出构造方法外的方法
方法具体划分：
a：根据返回值
有明确返回值方法
返回void类型的方法
b：根据形式参数
无参方法
带参方法
6、类的标准的代码写法

类
成员变量
构造方法
无参构造方法
带参构造方法
成员方法
getXxx()
setXxx()
给成员变量赋值的方式
无参构造方法+setXxx()
带参构造方法

7、类的初始化

a：加载Student.class文件进内存
b：在栈内存为s开辟空间
c：在堆内存为学生对象开辟空间
d：对学生对象的成员变量进行默认初始化
e：对学生对象的成员变量进行显示初始化
f：通过构造方法对学生对象的成员变量赋值
g：学生对象初始化完毕，把对象地址赋值给s变量

8、static关键字

可以修饰成员变量和成员方法
（1）static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用
（2）static关键字注意事项
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法

9、静态内存图

10、静态变量和成员变量的区别

（1）所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
（2）内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
（3）内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
（4）调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用

11、代码块

   在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
a：局部代码块 
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
b：构造代码块 
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
c：静态代码块 在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。

12、类与对象练习

例3-1

class  MyMathTest{public static void main(String[] args){MyMath mm = new MyMath();//创建对象System.out.println(mm.add(5,8));System.out.println(mm.sub(5,8));System.out.println(mm.mul(5,8));System.out.println(mm.div(5,8));System.out.println(mm.div(5.0,8.0));System.out.println("-----------");//使用匿名对象System.out.println(new MyMath().add(5,8));System.out.println(new MyMath().sub(5,8));}}class MyMath{//构造方法 //无参  默认的//有参  无//成员方法 //特有方法 public int add(int a,int b){return a + b;} public int sub(int a,int b){return a - b;} public int mul(int a,int b){return a * b;} public int div(int a,int b){return a / b;  } public double div(double a,double b){return a / b;  } }

例3-2

class  GodnessTest{public static void main(String[] args){//创建女神对象Godness g = new Godness("weibo",19,"女生");g.show();Godness g2 = new Godness("gaoqi",22,"女孩");g2.show();Godness g3 = new Godness("lingjian",20);g3.show();Godness g4 = new Godness("gaoqi",22,"女孩");g4.show();g4.sleep();System.out.println("------------------"); //static方法调用方法,类名.方法名()Godness.sleep();Godness.sex;g.show();System.out.println(g.sex);}}class  Godness {//成员变量 String name ; int age;//构造方法//无参 Godness(){} //有参Godness (String name, int age,String sex ){this.name = name;this.age = age;this.sex = sex;}Godness (String name, int age ){this.name = name;this.age = age;}//成员方法 //get /set public String getName(){return this.name;}public void setName(String name){this.name = name;}public int getAge(){return this.age;}public void setAge(int age){this.age = age;}//特有方法 //吃饭 public void eat(String food){System.out.println(this.name +"爱吃" + food);}//唱歌public void sing(){System.out.println(this.name +"爱唱歌");}static String sex;static String country;//自我介绍public void show(){System.out.println(name +"--"+age +"--" +sex);}public static void sleep(){//System.out.println(name + "洗洗睡了~~~");  //错误: 无法从静态上下文中引用非静态 变量 nameSystem.out.println(sex + "洗洗睡了~~~");}}