java--努力且进步着:面向对象(1)《java进阶篇》--黑马程序员

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

面向对象

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

1 面向对象思想概述

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

面向对象思想特点

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

可以将复杂的事情简单化

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

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

         软件整个的开发流程:

         1.分析;

         2.设计;

         3.编程(开发):

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

         以"面向对象"的方式:

         1.面向对象分析:

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

                                     Java基础班学员:学科、学号,姓名、性别、年龄;

                                     IOS班学员:学科、学号、姓名、性别、年龄;

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

                                     ....

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

IOS讲师:编号、学科、姓名、性别、年龄;

JavaEE讲师:编号、学科、姓名、性别、年龄;

....


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

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

         1.学员类:

                   学科:

                   学号:

                   姓名:

                   性别:

                   年龄:

         2.讲师类:

                   编号:

                   学科:

                   姓名:

                   性别:

                   年龄:

         3.员工类:

                  ........

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

                   1.定义类:

                            学员类:

                            讲师类:

                            员工类:.....

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

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

//定义学生类

1 class Student{
2     //属性-->成员变量:就跟我们以前定义变量一样,只不过这个变量定义在"类体中"
3     String stuNo;//学员编号
4     String name;//姓名
5     char sex;//性别;
6     int age;//年龄;
7     int score; //分数
8     //行为
9     }

 

 1 class Demo
 2 
 3 {
 4 
 5          public static void main(String[] args)
 6 
 7          {
 8 
 9                    //我要记录一个学员信息:
10 
11                    Student s = new Student();//在内存中产生空间
12 
13                    System.out.println("**********堆空间的默认值********");
14 
15                    //先打印属性值
16 
17                    System.out.println(s.stuNo);
18 
19                    System.out.println(s.name);
20 
21                    System.out.println(s.sex);
22 
23                    System.out.println(s.age);
24 
25                    System.out.println(s.score);
26 
27                   System.out.println("**********************************");
28 
29                   //可以对空间进行访问,并赋值
30 
31                    s.stuNo = "it001";
32 
33                    s.name = "刘德华";
34 
35                    s.sex = '男';
36 
37                    s.age = 20;
38 
39                    s.score = 88;
40 
41                    //访问数据成员
42 
43                    System.out.println("学号:" + s.stuNo);
44 
45                    System.out.println("姓名:" + s.name);
46 
47                    System.out.println("性别:" + s.sex);
48 
49                    System.out.println("年龄:" + s.age);
50 
51                    System.out.println("分数:" + s.score);
52 
53  
54 
55                    //记录第二个学员信息:
56 
57                    Student stu2 = new Student();
58 
59                    stu2.stuNo = "it002";
60 
61                    stu2.name = "张学友";
62 
63                    stu2.sex = '男';
64 
65                    stu2.age = 22;
66 
67                    stu2.score = 90;
68 
69          }
70 
71 }
72 
73  

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不会为其赋予默认的初始值;

 1 class Student
 2 
 3 {
 4 
 5               //成员变量
 6 
 7               String name;
 8 
 9               int age = 20;//OK的。定义,并同时初始值。
10 
11 //          age = 20;//这种语句不能出现在类体中;
12 
13               char sex;
14 
15               void show(){
16 
17                             //局部变量
18 
19                             int num = 20;
20 
21               }
22 
23 }
24 
25 class Demo
26 
27 {
28 
29               public static void main(String[] args)
30 
31               {
32 
33                             //局部变量
34 
35                             int num = 10;
36 
37                             //局部变量:for循环结束后,i变量消失
38 
39                             for(int i = 0;i < 10 ;i++){
40 
41                             }
42 
43                             //局部变量:b:在if体被执行时,变量b被创建。只要if语句完毕,b变量就立即消失;
44 
45                             if(1 == 1){
46 
47                                           int b = 10;
48 
49  
50 
51                             }
52 
53                             int a;
54 
55               //          a = a + 10;//错误的,编译错误
56 
57                             a = 10;//OK
58 
59                             System.out.println(a);
60 
61               }
62 
63 }

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

 1 class Student{
 2     String name;
 3     int age ;
 4     char sex;
 5 }
 6 class StudentTools{
 7 void printStudent(Student stu){
 8 //    stu.name = "章子怡";
 9         System.out.println(stu.name + "," + stu.age + "," + stu.sex);
10     }
11 }
12 class Demo 
13 {
14 public static void main(String[] args) 
15     {
16         Student stu1 = new Student();//stu1 = 0x2233
17         stu1.name = "刘德华";
18         stu1.age = 20;
19         stu1.sex = '男';
20     //    System.out.println(stu1.name + "," + stu1.age + "," + stu1.sex);
21     //    printStudent(stu1);//把stu1的引用传给了方法:printStudent(0x2233)
22         StudentTools st = new StudentTools();
23         st.printStudent(stu1);
24         Student stu2 = new Student();//stu2 = 0x4455
25         stu2.name = "张学友";
26         stu2.age = 22;
27 stu2.sex = '男';
28     //    System.out.println(stu2.name + "," + stu2.age + "," + stu2.sex);
29     //    printStudent(stu2);//printStudent(0x4455)
30         st.printStudent(stu2);
31     }
32     //定义方法,打印一个Student对象的信息
33     public static void printStudent(Student stu){//形参:表示接受一个"Student对象的引用(地址)"
34         stu.name = "章子怡";
35         System.out.println(stu.name + "," + stu.age + "," + stu.sex);
36     }
37 }

匿名对象的概述和应用

         匿名对象:

         1.没有名字的对象;

     new Student();

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

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

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

 1 class Student{
 2     String name;
 3     int age ;
 4     char sex;
 5 }
 6 class StudentTools{
 7     void printStudent(Student stu){
 8         System.out.println(stu.name + "," + stu.age + "," + stu.sex);
 9     }
10 }
11 class Demo 
12 {
13     public static void main(String[] args) 
14     {
15     //以前我们定义的对象都是有名字的;
16 //我们可以利用这个名字,反复的访问堆中的内容;
17         Student stu = new Student();
18         stu.name = "章子怡";
19         stu.age = 20;
20         stu.sex = '女';
21         //匿名对象
22         new Student();
23         //例如:如果只需要调用一次StudentTools类的方法printStudent().这时,可以定义一个匿名的StudentTools类对象
24         new StudentTools().printStudent(stu);
25         //例如:调用printStudent()方法也可以传递一个匿名的Student对象
26         new StudentTools().printStudent(new Student());
27     }
28 }

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修饰符:限制成员,只能在本类的内部被其它成员访问。在其它类中,不能被访问。

 1 class Student{
 2     private String name;
 3     private int age;
 4     private char sex;
 5     //对外的get和set方法
 6     void setName(String n){
 7         name = n;
 8     }
 9     String getName(){
10         return name;
11     }
12     void setAge(int a){
13         age = a;
14     }
15     int getAge(){
16         return age;
17     }
18     void setSex(char c){
19         sex = c;
20     }
21     char getSex(){
22         return sex;
23     }
24 }
25 class Demo {
26     public static void main(String[] args) {
27         Student stu = new Student();
28     //    stu.setName = "刘德华";//错误,不是访问方法
29         stu.setName("刘德华");
30         stu.setAge(20);
31         stu.setSex('男');
32         System.out.println(stu.getName() + "," + stu.getAge()+"," + stu.getSex());
33     }
34 }

11 this关键字的概述和应用

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

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

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

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

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

           在实例化这个类的对象时,会为其赋值。值为:当前对象的引用;

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

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

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

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

 1 class Student{
 2 
 3          String name;
 4 
 5          void show(){
 6 
 7 String name = "章子怡";//局部变量,覆盖同名的"成员变量"
 8 
 9                    System.out.println("大家好:我叫:" + name);//如果直接使用name变量,就近原则
10 
11                    System.out.println("成员变量的name = " + this.name);//使用this访问成员变量的name属性
12 
13          }
14 
15          void fun(){
16 
17                    show();//OK的
18 
19                    this.show();//OK的。效果同上面是一样的。
20 
21          }
22 
23 }
24 
25 class Demo {
26 
27          public static void main(String[] args) {
28 
29                    Student stu = new Student();
30 
31                    stu.name = "刘德华";
32 
33                    stu.show();
34 
35          }
36 
37 }

 

 



转载于:https://www.cnblogs.com/linmusen/p/4709230.html

你可能感兴趣的:(java--努力且进步着:面向对象(1)《java进阶篇》--黑马程序员)