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

 ------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------

面向对象：

     面向对象是相对面向过程而言

     面向对象和面向过程都是一种思想

面向过程：关注的过程

面向对象：关注的对象（结果）

例如：做菜

面向过程:买菜、洗菜、做菜、吃饭、刷碗、倒垃圾

面向对象：找个对象（男\女朋友）,让他去做饭

 

面向对象思想的特点：

1：是一种符合人们思考习惯的思想

2：可以将复杂的事情简单化

3：将程序员从执行者转换成了指挥者

 

举例：

旅游：

面向过程：查找路线、预订宾馆、订票、坐车、旅游

面向对象：找个旅行社 报团旅游

          

买电脑：

面向过程：查阅资料、去电脑城、砍价还价、购买电脑

面向对象：找个懂电脑的朋友，让他做所有事情

 

怎么样才算面向对象?

请按照我下面的几个步骤：

A:分析有哪些类。

B:分析类应该有什么。

C:分析类与类之间的关系。

 

举例：

          把大象装进冰箱。

 

面向过程：

A:开冰箱门

B:把大象装进去

C:关冰箱门

 

代码体现：

class Test {

     publicstatic void main(String[] args){

          /*

          System.out.println("开冰箱门");

          System.out.println("把大象装进去");

          System.out.println("把大象装进去");

          System.out.println("把大象装进去");

          System.out.println("关冰箱门");

          */

 

          //在面向过程中，有些动作要重复执行，定义方法

          open();

          in();

          in();

          in();

          close();

          }

                

          publicstatic void open() {

                System.out.println("开冰箱门");

          }

 

          publicstatic void in() {

                System.out.println("把大象装进去");

          }

 

          publicstatic void close(){

                System.out.println("关冰箱门");

          }

     }

 

面向对象：(UML统一建模语言+设计模式设计师)

          A:分析有哪些类。

                大象类

                冰箱类

                测试类

          B:分析类应该有什么。

                大象类

                     把大象装进去

                冰箱类

                     开冰箱门

                     关冰箱门

                测试类

                     main方法

          C:分析类与类之间的关系。

                在测试类中，创建大象和冰箱对象，并调用其功能。

 

          代码体现：

                class大象 {

                     publicvoid in() {

                           System.out.println("把大象装进去");

                     }

                }

 

                class冰箱 {

                     publicvoid open() {

                           System.out.println("开冰箱门");

                     }

 

                     publicvoid close(){

                           System.out.println("关冰箱门");

                     }

                }

 

                classTest {

                     publicstatic void main(String[] args) {

                           冰箱 b = new冰箱();

                           大象 d = new大象();

 

                           b.open();

                           d.in();

                           b.close();

                     }

                }

 

 

类与对象：

Java语言是为了描述现实世界事物的。

现实世界事物又是怎么体现的:

          

属性：外在的特征

 

                事物          属性

                学生          姓名、性别、年龄

                汽车          品牌、颜色、价格

 

      行为：具备的功能

                事物          行为

                学生          学习、睡觉、吃饭

                汽车          加速、减速、转弯

 

     把现实世界的事物通过Java语言来体现，而Java语言中最基本的单位是：类。

所以，每一个显示世界的具体事物其实对应的是一个类。

 

现实世界事物   ：  类

属性    ：  成员变量

行为    ：  成员方法

 

类：类是很多对象的抽象表现形式。

对象：对象是类的具体表现形式。

     学生：类

     小明：对象

 

类的组成：

A:成员变量

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

a:类中位置区别

成员变量：类中，方法外。

局部变量：类中，方法声明上，或者方法体中。

b:内存位置区别

成员变量：堆内存。

局部变量：栈内存。

c:生命周期区别

成员变量：随着对象的创建而存在，随着对象的消失而消失。

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

d:初始化值区别

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

局部变量：没有默认初始化值。先定义，再赋值，最后使用。

 

/*

     一个java源文件中可以有多个类class，但是 java源文件的名字只能有一个

 

     java源文件的名字要与包含main方法的类的名字一致

 

 

     描述学生事物

                属性：

                     姓名(name)、性别(sex)、年龄(age)

                行为：

                     学习(study)、吃饭(eat)、睡觉(sleep)

 

     java中，通过类描述学生事物

          学生类

                成员变量： 就是一个变量,位置必须在类中，方法外

                     姓名(name)、性别(sex)、年龄(age)

 

                成员方法： 就是一个函数不加static

                     学习(study)、吃饭(eat)、睡觉(sleep)

 

     通过java代码描述学生类

          

 

*/

class Student {

     //成员变量：

     //姓名(name)

     Stringname;

     //性别(sex)

     charsex;

     //年龄(age)

     intage;

 

     //成员方法：

     //学习(study)

     publicvoid study () {

          System.out.println(name+ "在学习");

     }

 

     //吃饭(eat)

     publicvoid eat() {

          System.out.println(name + "在吃饭");

     }

 

     //睡觉(sleep)

     publicvoid sleep () {

          System.out.println(name+ "在睡觉");

     }

 

}

 

 

/*

想使用学生中的成员变量和成员方法？怎么实现呢？

我们需要得到学生类的一个具体体现

 

类：它是属性和行为的集合。它是一个抽象的概念

对象：为了明确age具体是哪个学生的age，这个时候我们需要得到一个具体的学生。

那么，这个学生就是类的体现，叫对象。

          

创建对象:

格式：类名对象名 = new类名();

Student stu = new Student();

使用学生中的成员变量和成员方法?

必须要通过对象来调用

格式

成员变量： 对象名.成员变量;

成员方法： 对象名.成员方法;

成员变量是有初始化值的。

*/

class Student {

     //成员变量：

     //姓名(name)

     Stringname;

     //性别(sex)

     charsex;

     //年龄(age)

     intage;

 

     //成员方法：

     //学习(study)

     publicvoid study () {

          System.out.println(name+ "在学习");

     }

 

     //吃饭(eat)

     publicvoid eat() {

          System.out.println(name + "在吃饭");

     }

 

     //睡觉(sleep)

     publicvoid sleep () {

          System.out.println(name+ "在睡觉");

     }

 

}

 

class StudentTest {

     publicstatic void main(String[] args) {

          

          //创建一个学生

          //类名对象名 = new类名();

          Studentstu = new Student();

 

          //成员变量： 对象名.成员变量;

          //使用成员变量

          System.out.println(stu.name+ "***" + stu.sex + "***" + stu.age);

          

          //为成员变量赋值

          stu.name= "小明";

          stu.sex= '男';

          stu.age= 15;

 

          //再次使用成员变量

          System.out.println(stu.name+ "***" + stu.sex + "***" + stu.age);    

 

          //成员方法： 对象名.成员方法;

          stu.sleep();

          stu.eat();

          stu.study();

     }

}

 

匿名对象(Anonymity)：

     就是没有名字的对象

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

 

匿名对象两种使用情况：

1：当对对象方法仅进行一次调用的时:

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

 

代码体现：

class Person {

     Stringname = "张三";

     intage = 18;

 

     publicvoid show(){

          System.out.println("name="+name +",age="+ age);

     }

}

 

class Test {

     publicvoid method (Person p) {

                    p.show();

     }

}

 

class AnonymityDemo{

     publicstatic void main(String[] args) {

 

          Personp = new Person();

 

          Testt = new Test();

          t.method(p);

           t.method( new Person() );

 

        }

}

 

封装(Encapsulation):

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

       我们发现当前学生对象中age可以随机赋值，这可能会出现负数。这是不符合逻辑的

       那么，我们就需要约束age的使用范围，让age只能在Student类中使用，外面不能用,怎么实现呢？

 

private关键字：

       A:是一个权限修饰符。

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

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

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

     E:如果想获取 private修饰的变量 可以编写公共的 get方法

     F：如果想设置 private修饰的变量 可以编写公共的 set方法

 

代码体现：

/*

     封装的使用：

            成员变量都是私有的

            成员方法都是公共的

*/

class Person {

     privateString name;

     privateint age;

 

     publicvoid setName (String n) {

          name= n;

     }

 

     publicString getName () {

          returnname;

     }

 

     publicvoid setAge (int a) {

          age= a;

     }

 

     publicint getAge () {

          returnage;

     }

}

 

class EncapsulationTest {

     publicstatic void main(String[] args) {

          

          Personp = new Person();

          //赋值

          p.setName("李四");

          p.setAge(18);

 

          //获取值

          System.out.println(p.getName()+ "***" + p.getAge() );

     }

}

 

 

构造函数（constructor）：

     特点：

             1:函数名与类名相同

             2:不用定义返回值类型

             3: 没有具体的返回值。

 

     作用：

     给对象进行初始化。

     注意：

          1:类中没有构造函数， JVM会自动给我们创建空参数的构造函数

          2:如果有多个构造函数的时候，它们之间以重载的形式存在

          3: 如果手动的指定了构造函数，那么，JVM就不会再为我们创建空参数的构造函数

          4:避免上面的情况发生，需要自己手动的编写空参数的构造函数

 

          推荐：以后创建类就把空参数的构造函数写出来

 

代码体现：

      class Person {

               privateString name;

 

              //空参数的构造函数

            publicPerson(){

                       System.out.println("空参数的构造函数");

                        name= "张三";

           }

 

           //带参数的构造函数

            publicPerson(String n) {

                      name= n;

             }

 

           publicvoid setName (String n) {

                     name= n;

           }

 

           publicString getName () {

                    returnname;

          }

      }

 

 

class ConstructorDemo {

          publicstatic void main(String[] args) {

          Personp = new Person();

          System.out.println(p.getName() );

 

          Personp2 = new Person("李四");

          System.out.println(p2.getName() );

 

          Personp3 = new Person("王五");

          System.out.println(p3.getName() );

 

 

     }

}

 

this关键字：

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

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

 

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

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

     2： 局部变量隐藏全局变量

       3：构造函数中用

 

如果局部变量与成员变量同名，那么想将局部变量赋值给成员变量

       可以 this.成员变量 = 局部变量 ;

 

代码体现：

class Person {

     privateString name;

     privateint age;

      //空参的构造方法

     publicPerson() { }

      //带参的构造方法

     publicPerson (String name, int age) {

          this.name= name;

          this.age= age;

       

     }

     //set方法

     publicvoid setName (String name) {

          this.name= name;

     }

     //get方法

     publicString getName () {

          returnname;

     }

 

     publicvoid setAge (int age) {

          this.age= age;

     }

 

     publicint getAge () {

          returnage;

     }

}

 

 

class ThisDemo {

     publicstatic void main(String[] args) {

          

          Personp = new Person("郭靖", 18);

          System.out.println(p.getName()+ "***" + p.getAge() );

 

          Personp2 = new Person();

          p2.setName("黄蓉");

          p2.setAge(16);

          System.out.println(p2.getName()+ "***" + p2.getAge() );

 

     }

}

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------                                               

详细请查看：http://edu.csdn.net