java--努力且进步着：面向对象（1）《java进阶篇》--黑马程序员

面向对象

主要内容：《  思想概述、设计实现、成员变量和局部变量、类名作为形参、匿名对象、封装、private关键字、this关键字 》

1 面向对象思想概述

面向对象是基于面向过程的编程思想

面向对象思想特点

是一种更符合我们思想习惯的思想

可以将复杂的事情简单化

将我们从执行者变成了指挥者

2 面向对象开发设计以及特征

         软件整个的开发流程：

         1.分析；

         2.设计；

         3.编程(开发)：

         需求：给传智播客北京校区做一套系统，要求能记录学员信息、教师信息、员工信息、课程、班级、正在上课的班级.....

         以"面向对象"的方式：

         1.面向对象分析：

                   1).要明确系统中要记录哪些信息：

                                     Java基础班学员：学科、学号，姓名、性别、年龄；

                                     IOS班学员：学科、学号、姓名、性别、年龄；

                                     JavaEE班学员：学科、学号、姓名、性别、年龄

                                     ....

Java基础讲师：编号、学科、姓名、性别、年龄；

IOS讲师：编号、学科、姓名、性别、年龄；

JavaEE讲师：编号、学科、姓名、性别、年龄；

....

....学前咨询的员工：

2.面向对象设计：将上述信息进行"分类"，并明确每个"类"中的具体成员：

         1.学员类：

                   学科：

                   学号：

                   姓名：

                   性别：

                   年龄：

         2.讲师类：

                   编号：

                   学科：

                   姓名：

                   性别：

                   年龄：

         3.员工类：

                  ........

3.面向对象开发：代码实现：

                   1.定义类：

                            学员类：

                            讲师类：

                            员工类:.....

//可以将多个类定义到同一个.java文件中，但是这个文件中，只能有一个public类。而且这个public类的

//类名，必须和文件名同名。

//定义学生类

class Student{
    //属性-->成员变量：就跟我们以前定义变量一样，只不过这个变量定义在"类体中"
    String stuNo;//学员编号
    String name;//姓名
    char sex;//性别；
    int age;//年龄；
    int score; //分数
    //行为
    }

 

class Demo

{

         public static void main(String[] args)

         {

                   //我要记录一个学员信息：

                   Student s = new Student();//在内存中产生空间

                   System.out.println("**********堆空间的默认值********");

                   //先打印属性值

                   System.out.println(s.stuNo);

                   System.out.println(s.name);

                   System.out.println(s.sex);

                   System.out.println(s.age);

                   System.out.println(s.score);

                  System.out.println("**********************************");

                  //可以对空间进行访问，并赋值

                   s.stuNo = "it001";

                   s.name = "刘德华";

                   s.sex = '男';

                   s.age = 20;

                   s.score = 88;

                   //访问数据成员

                   System.out.println("学号：" + s.stuNo);

                   System.out.println("姓名：" + s.name);

                   System.out.println("性别：" + s.sex);

                   System.out.println("年龄：" + s.age);

                   System.out.println("分数：" + s.score);

 

                   //记录第二个学员信息：

                   Student stu2 = new Student();

                   stu2.stuNo = "it002";

                   stu2.name = "张学友";

                   stu2.sex = '男';

                   stu2.age = 22;

                   stu2.score = 90;

         }

}

 

3 学生类的定义

定义学生类：
    类名：Student
        属性：姓名：性别：年龄：
        行为：自我介绍:学习:
class Student{
    //属性-->成员变量
    String name;//OK的。当实例化(new)时，在堆空间中会自动初始化；
//    String name = null;//OK的。显示初始为：null;
    char sex;
//    char sex = '男';//OK的
    int age;
    //行为-->成员方法：跟我们以前学习的"方法"是一样的。可以有返回值，可以形参。
    //这里我们定义"成员方法"时，先暂时不需要：public static
    //成员方法，可以访问"成员变量"
    void show(){
        System.out.println("大家好，我叫：" + name + "，性别：" + sex + "，今年：" + age + " 岁！");
    }
    void study(){
    System.out.println("我们学习Java");
    }
//以下语句不能出现在类体中
    System.out.println("aaaa");//不可以
for(int i = 0;i < 10 ;i++){
    }
}

类似还有手机类的定义；

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

成员变量：定义在"类体"中；可以是任何的Java类型；

局部变量：定义在"方法"内；可以是任何的Java类型；

区别：

1.定义的位置：

1)员变量：定义在"类体"中；

2).局部变量：定义在某个"方法"内；

2.内存中的位置：

1).成员变量：在"堆"中；

2).局部变量(基本数据类型)：在"栈"中；

3.生命周期：

1).成员变量：实例化一个对象时，在堆中产生；如果没有任何引用来引用这块空间，后期由

                                        "垃圾回收器"不定期检查，并清理。

2).局部变量：当所在的作用域代码块被执行，变量产生空间；当变量所在的作用域代码块执行完毕，会被立即从栈中清除掉；

4.初始化方式和初始化值：

1).成员变量：

         初始化方式：由Java自动初始化；

                   初始化值：整数：0

                            浮点：0.0

                            符：'\u0000'

                            布尔：false

                            String和其他引用类型：null;

2).局部变量：

                   初始化方式：必须手动显示的初始化，否则不能访问此变量的值；

                   Java不会为其赋予默认的初始值；

class Student

{

              //成员变量

              String name;

              int age = 20;//OK的。定义，并同时初始值。

//          age = 20;//这种语句不能出现在类体中；

              char sex;

              void show(){

                            //局部变量

                            int num = 20;

              }

}

class Demo

{

              public static void main(String[] args)

              {

                            //局部变量

                            int num = 10;

                            //局部变量:for循环结束后，i变量消失

                            for(int i = 0;i < 10 ;i++){

                            }

                            //局部变量：b:在if体被执行时，变量b被创建。只要if语句完毕，b变量就立即消失；

                            if(1 == 1){

                                          int b = 10;

 

                            }

                            int a;

              //          a = a + 10;//错误的，编译错误

                            a = 10;//OK

                            System.out.println(a);

              }

}

方法的形式参数是类名的时候如何调用

class Student{
    String name;
    int age ;
    char sex;
}
class StudentTools{
void printStudent(Student stu){
//    stu.name = "章子怡";
        System.out.println(stu.name + "," + stu.age + "," + stu.sex);
    }
}
class Demo 
{
public static void main(String[] args) 
    {
        Student stu1 = new Student();//stu1 = 0x2233
        stu1.name = "刘德华";
        stu1.age = 20;
        stu1.sex = '男';
    //    System.out.println(stu1.name + "," + stu1.age + "," + stu1.sex);
    //    printStudent(stu1);//把stu1的引用传给了方法:printStudent(0x2233)
        StudentTools st = new StudentTools();
        st.printStudent(stu1);
        Student stu2 = new Student();//stu2 = 0x4455
        stu2.name = "张学友";
        stu2.age = 22;
stu2.sex = '男';
    //    System.out.println(stu2.name + "," + stu2.age + "," + stu2.sex);
    //    printStudent(stu2);//printStudent(0x4455)
        st.printStudent(stu2);
    }
    //定义方法，打印一个Student对象的信息
    public static void printStudent(Student stu){//形参：表示接受一个"Student对象的引用(地址)"
        stu.name = "章子怡";
        System.out.println(stu.name + "," + stu.age + "," + stu.sex);
    }
}

匿名对象的概述和应用

         匿名对象：

         1.没有名字的对象；

　　　　　new Student();

         2.有些时候，我们在以下情况下，可以使用匿名对象的方式：

                   1.对于某个类中的某个方法，只需要调用一次；

                   2.如果某个方法需要"某个对象的引用"(也就是形参是某个对象的引用)，如果我们调用方不需要这个形参的对象，只需要给方法传递一个引用即可，这时，可以使用传递一个匿名对象；

class Student{
    String name;
    int age ;
    char sex;
}
class StudentTools{
    void printStudent(Student stu){
        System.out.println(stu.name + "," + stu.age + "," + stu.sex);
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
    //以前我们定义的对象都是有名字的；
//我们可以利用这个名字，反复的访问堆中的内容；
        Student stu = new Student();
        stu.name = "章子怡";
        stu.age = 20;
        stu.sex = '女';
        //匿名对象
        new Student();
        //例如：如果只需要调用一次StudentTools类的方法printStudent().这时，可以定义一个匿名的StudentTools类对象
        new StudentTools().printStudent(stu);
        //例如：调用printStudent()方法也可以传递一个匿名的Student对象
        new StudentTools().printStudent(new Student());
    }
}

8 封装的概述

1.之前我们使用类时，都是直接访问"成员变量"；实际上这是一种不安全的方式；

         2.封装的概念：

                   1).将成员变量对外隐藏(private(私有的))

　　　　　　　2).对外可以有选择的提供set和get方法，对成员属性进行设置值和获取值的操作；

class Student{
    private String name;
    private int age;
    void show(){
        System.out.println("我叫：" + name);
    }
    void setName(String s){
        name = s;
    }
    void setAge(int a){
        if(a < 15 || a > 50){
            //抛出异常
        }
        age = a;
    }
    String getName(){
        return name;
    }
    int getAge(){
        return age;
    }
}
class Demo {
    public static void main(String[] args) {
        Student stu = new Student();
    //    stu.name = "刘德华";//当数据成员被私有化后，不能直接访问了；
    //    stu.age = 20;//当数据成员被私有化后，不能直接访问了；
        stu.setName("刘德华");
        stu.setAge(20);
        System.out.println(stu.getName() + "," + stu.getAge());
    }
}

 private关键字的概述和特点

private:是一个Java的访问修饰符，属于Java的关键字；作用就是控制成员的访问限制；

         Java中的访问修饰符：public,protected,(默认(什么都不写)),private(从限制最少到限制最多)

         private修饰符：限制成员，只能在本类的内部被其它成员访问。在其它类中，不能被访问。

class Student{
    private String name;
    private int age;
    private char sex;
    //对外的get和set方法
    void setName(String n){
        name = n;
    }
    String getName(){
        return name;
    }
    void setAge(int a){
        age = a;
    }
    int getAge(){
        return age;
    }
    void setSex(char c){
        sex = c;
    }
    char getSex(){
        return sex;
    }
}
class Demo {
    public static void main(String[] args) {
        Student stu = new Student();
    //    stu.setName = "刘德华";//错误，不是访问方法
        stu.setName("刘德华");
        stu.setAge(20);
        stu.setSex('男');
        System.out.println(stu.getName() + "," + stu.getAge()+"," + stu.getSex());
    }
}

11 this关键字的概述和应用

          在这个方法中怎么来区分是被哪个对象调用的？        

　　　 1.我们知道：方法体空间被多个对象共享。多个对象都会调用同一个方法体，

         2.在方法体内，如果访问成员变量的话，会隐式的使用this关键字：

         3.我们可以显示的使用this

         4.this是一个隐式的变量：

           在实例化这个类的对象时，会为其赋值。值为：当前对象的引用；

         5.我们可以显示的使用this调用当前对象的：成员变量和成员方法；

         6.有一种情况需要我们必须显示的使用this去访问成员变量：

                   当"局部变量"覆盖了同名的"成员变量"时。

                   在局部变量所在的方法内，要想访问被覆盖的成员变量，需要使用this即可访问；

class Student{

         String name;

         void show(){

String name = "章子怡";//局部变量，覆盖同名的"成员变量"

                   System.out.println("大家好：我叫：" + name);//如果直接使用name变量，就近原则

                   System.out.println("成员变量的name = " + this.name);//使用this访问成员变量的name属性

         }

         void fun(){

                   show();//OK的

                   this.show();//OK的。效果同上面是一样的。

         }

}

class Demo {

         public static void main(String[] args) {

                   Student stu = new Student();

                   stu.name = "刘德华";

                   stu.show();

         }

}