Java:面向对象--封装

1、面向对象的简单说明

 1 /*
 2     事物:
 3     属性    事物的信息描述
 4     行为    事物的功能
 5
 6     类:
 7     成员变量    事物的属性
 8     成员方法    事物的行为
 9
10     定义一个类,其实就是定义该类的成员变量和成员方法。
11
12     手机事物:
13         属性:品牌,价格,颜色...
14         行为:打电话,发短信,玩游戏...
15
16     手机类:
17         成员变量:品牌,价格,颜色
18         成员方法:打电话,发短信,玩游戏
19
20     成员变量:和以前变量的定义是一样的格式,但是位置不同,在类中方法外。
21     成员方法:和以前的方法定义是一样的格式,但是今天把static先去掉。
22 */
23 class Phone {
24     //品牌
25     String brand;
26     //价格
27     int price;
28     //颜色
29     String color;
30
31     //打电话的方法
32     public void call(String name) {
33         System.out.println("给"+name+"打电话");
34     }
35
36     //发短信的方法
37     public void sendMessage() {
38         System.out.println("群发短信");
39     }
40
41     //玩游戏的方法
42     public void playGame() {
43         System.out.println("玩游戏");
44     }
45 }

一个对象的内存分布:

两个对象的内存分部:

三个对象的内存分部:

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

 1 /*
 2     成员变量和局部变量的区别?
 3         A:在类中的位置不同
 4             成员变量:在类中方法外
 5             局部变量:在方法定义中或者方法声明上
 6         B:在内存中的位置不同
 7             成员变量:在堆内存
 8             局部变量:在栈内存
 9         C:生命周期不同
10             成员变量:随着对象的创建而存在,随着对象的消失而消失
11             局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
12         D:初始化值不同
13             成员变量:有默认初始化值
14             局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。
15
16         注意事项:
17             局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
18 */
19 class Varialbe {
20     //成员变量
21     //int num = 10;
22     int num; //0
23
24     public void show() {
25         //int num2 = 20; //局部变量
26         //可能尚未初始化变量num2
27         //int num2; //没有默认值
28         int num2 = 20;
29         System.out.println(num2);
30
31         //int num = 100;
32         System.out.println(num);
33     }
34 }
35
36
37 class VariableDemo {
38     public static void main(String[] args) {
39         Varialbe v = new Varialbe();
40
41         System.out.println(v.num); //访问成员变量
42
43         v.show();
44
45     }
46 }

3、形式参数是类名

 1 /*
 2     形式参数的问题:
 3         基本类型:形式参数的改变不影响实际参数
 4         引用类型:形式参数的改变直接影响实际参数
 5 */
 6 //形式参数是基本类型
 7 class Demo {
 8     public int sum(int a,int b) {
 9         return a + b;
10     }
11 }
12
13 //形式参数是引用类型
14 class Student {
15     public void show() {
16         System.out.println("我爱学习");
17     }
18 }
19
20 class StudentDemo {
21     //当一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象。
22     public void method(Student s) { //调用的时候,把main方法中的s的地址传递到了这里 Student s = new Student();
23         s.show();
24     }
25 }
26
27 class ArgsTest {
28     public static void main(String[] args) {
29         //形式参数是基本类型的调用
30         Demo d = new Demo();
31         int result = d.sum(10,20);
32         System.out.println("result:"+result);
33         System.out.println("--------------");
34
35         //形式参数是引用类型的调用
36         //需求:我要调用StudentDemo类中的method()方法
37         StudentDemo sd = new StudentDemo();
38         //创建学生对象
39         Student s = new Student();
40         sd.method(s); //把s的地址给到了这里
41     }
42 }

4、匿名对象

 1 /*
 2     匿名对象:就是没有名字的对象。
 3
 4     匿名对象的应用场景:
 5         A:调用方法,仅仅只调用一次的时候。
 6             注意:调用多次的时候,不适合。
 7             那么,这种匿名调用有什么好处吗?
 8                 有,匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
 9         B:匿名对象可以作为实际参数传递
10 */
11 class Student {
12     public void show() {
13         System.out.println("我爱学习");
14     }
15 }
16
17 class StudentDemo {
18     public void method(Student s) {
19         s.show();
20     }
21 }
22
23 class NoNameDemo {
24     public static void main(String[] args) {
25         //带名字的调用
26         Student s = new Student();
27         s.show();
28         s.show();
29         System.out.println("--------------");
30
31         //匿名对象
32         //new Student();
33         //匿名对象调用方法
34         new Student().show();
35         new Student().show(); //这里其实是重新创建了一个新的对象
36         System.out.println("--------------");
37
38
39         //匿名对象作为实际参数传递
40         StudentDemo sd = new StudentDemo();
41         //Student ss = new Student();
42         //sd.method(ss); //这里的s是一个实际参数
43         //匿名对象
44         sd.method(new Student());
45
46         //在来一个
47         new StudentDemo().method(new Student());
48      }
49 }

5、封装和private关键字

 1 /*
 2     private:
 3         是一个权限修饰符
 4         可以修饰成员变量和成员方法
 5         被其修饰的成员只能在本类中被访问
 6 */
 7 class Demo {
 8     //int num = 10;
 9     //用private修饰
10     private int num = 10;
11
12     public void show() {
13         System.out.println(num);
14     }
15
16     private void method() {
17         System.out.println("method");
18     }
19
20     public void function() {
21         method();
22     }
23 }
24
25 class PrivateDemo {
26     public static void main(String[] args) {
27         Demo d = new Demo();
28         //不能方法私有的成员变量
29         //System.out.println(d.num);
30         d.show();
31         //不能访问私有的成员方法
32         //d.method();
33         d.function();
34     }
35 }
 1 /*
 2     定义一个学生类:
 3         成员变量:name,age
 4         成员方法:show()方法
 5
 6     我们在使用这个案例的过程中,发现了一个问题:
 7         通过对象去给成员变量赋值,可以赋值一些非法的数据。
 8         这是不合理的。
 9         应该是这个样子的:在赋值之前,先对数据进行判断。
10         判断到底在哪里做比较合适呢?
11         StudentDemo类是一个测试类,测试类一般只创建对象,调用方法。
12         所以,这个判断应该定义在Student类中。
13         而我们在成员变量的位置可不可以进行数据判断呢?
14         是不可以的,因为做数据校验,必须要依靠一些逻辑语句。
15         逻辑语句是应该定义在方法中的,所以,我们最终决定在Student类中提供一个方法
16         来对数据进行校验。
17
18     按照我们前面的分析,我们给出了一个方法进行校验。
19     但是呢,它偏偏不调用方法来赋值,还是直接赋值了,
20     这样我们的方法就没有起到作用。
21     我就应该要求你必须使用我的方法,而不能直接调用成员变量赋值。
22     怎么去强制要求不能直接使用成员变量呢?
23         针对这种情况,Java就提供了一个关键字 private
24
25     private:私有的。可以修饰成员变量和成员方法。
26         注意:被private修饰的成员只能在本类中访问。
27
28     其实我讲到现在讲解的是一个封装的思想。
29     封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
30 */
31 class Student {
32     //姓名
33     String name;
34     //年龄
35     private int age;
36
37     //写一个方法对数据进行校验
38     /*
39         返回值类型:void
40         参数列表:int a
41     */
42     public void setAge(int a) {
43         if(a < 0 || age > 120) {
44             System.out.println("你给的年龄有问题");
45         }else {
46             age = a;
47         }
48     }
49
50
51     //show()方法,显示所有成员变量值
52     public void show() {
53         System.out.println("姓名:"+name);
54         System.out.println("年龄:"+age);
55     }
56 }
57
58 class StudentDemo {
59     public static void main(String[] args) {
60         //创建学生对象
61         Student s = new Student();
62         s.show();
63         System.out.println("--------------");
64
65         //给成员变量赋值
66         s.name = "林青霞";
67         //s.age = 27;
68         s.setAge(27);
69         s.show();
70         System.out.println("--------------");
71
72         //给age赋值
73         //s.age = -27; //这个数据是不合理的
74         //通过方法给值
75         s.setAge(-27);
76         s.show();
77         System.out.println("--------------");
78     }
79 }
 1 /*
 2     封装和private的应用:
 3         A:把成员变量用private修饰
 4         B:提高对应的getXxx()和setXxx()方法
 5 */
 6 //定义学生类
 7 class Student {
 8     //姓名
 9     private String name;
10     //年龄
11     private int age;
12
13     //姓名获取值
14     public String getName() {
15         return name;
16     }
17
18     //姓名设置值
19     public void setName(String n) {
20         name = n;
21     }
22
23     //年龄获取值
24     public int getAge() {
25         return age;
26     }
27
28     //年龄赋值
29     public void setAge(int a) {
30         age = a;
31     }
32 }
33
34 //测试类
35 class StudentTest {
36     public static void main(String[] args) {
37         //创建学生对象
38         Student s = new Student();
39
40         //使用成员变量
41         //错误:被私有修饰了,外界不能直接访问了
42         //System.out.println(s.name+"---"+s.age);
43         System.out.println(s.getName()+"---"+s.getAge());
44
45         //给成员变量赋值
46         //s.name = "林青霞";
47         //s.age = 27;
48         //通过方法给赋值
49         s.setName("林青霞");
50         s.setAge(27);
51         System.out.println(s.getName()+"---"+s.getAge());
52     }
53 }

6、this关键字

 1 /*
 2     我们曾经曰:起名字要做到见名知意。
 3
 4     this:是当前类的对象引用。简单的记,它就代表当前类的一个对象。
 5
 6         注意:谁调用这个方法,在该方法内部的this就代表谁。
 7
 8     this的场景:
 9         解决局部变量隐藏成员变量
10 */
11 //定义学生类
12 class Student {
13     //姓名
14     private String name;
15     //年龄
16     private int age;
17
18     //姓名获取值
19     public String getName() {
20         return name;
21     }
22
23     //姓名设置值
24     public void setName(String name) { //name = "林青霞";
25         //name = name; //变量的使用规则:就近原则
26         //这里是类名,目前还没有说过类似的用法,所以这个是有问题的
27         //这里的调用只能通过对象名
28         //这个对象如果存在,它应该代表的是Student的一个对象。
29         //那么,谁能够代表当前类的对象呢? java就提供了一个关键字 this
30         //Student.name = name;
31         this.name = name;
32     }
33
34     //年龄获取值
35     public int getAge() {
36         return age;
37     }
38
39     //年龄赋值
40     public void setAge(int age) {
41         this.age = age;
42     }
43 }
44
45 //测试类
46 class StudentTest {
47     public static void main(String[] args) {
48         //创建学生对象
49         Student s = new Student();
50
51         //给成员变量赋值
52         s.setName("林青霞");
53         s.setAge(27);
54         //获取数据
55         System.out.println(s.getName()+"---"+s.getAge());
56     }
57 }
 1 /*
 2     标准的代码改进版
 3
 4     this:哪个对象调用那个方法,this就代表那个对象
 5 */
 6 class Student {
 7     private String name;
 8     private int age;
 9
10     public String getName() {
11         return name; //这里其实是隐含了this
12     }
13
14     public void setName(String name) {
15         this.name = name;
16     }
17
18     public int getAge() {
19         return age;
20     }
21
22     public void setAge(int age) {
23         this.age = age;
24     }
25 }
26
27 class StudentTest2 {
28     public static void main(String[] args) {
29         //创建一个对象
30         Student s1 = new Student();
31         s1.setName("林青霞");
32         s1.setAge(27);
33         System.out.println(s1.getName()+"---"+s1.getAge());
34
35         //创建第二个对象
36         Student s2 = new Student();
37         s2.setName("刘意");
38         s2.setAge(30);
39         System.out.println(s2.getName()+"---"+s2.getAge());
40     }
41 }

7、构造方法

 1 /*
 2     构造方法:
 3         给对象的数据进行初始化
 4
 5     格式:
 6         A:方法名与类名相同
 7         B:没有返回值类型,连void都没有
 8         C:没有具体的返回值
 9 */
10 class Student {
11     private String name; //null
12     private int age; //0
13
14     public Student() {
15         System.out.println("这是构造方法");
16     }
17 }
18
19 class ConstructDemo {
20     public static void main(String[] args) {
21         //创建对象
22         Student s = new Student();
23         System.out.println(s); //[email protected]
24     }
25 }
 1 /*
 2     我们一直在使用构造方法,但是,我们确没有定义构造方法,用的是哪里来的呢?
 3
 4     构造方法的注意事项:
 5         A:如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
 6         B:如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
 7             注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法
 8
 9     给成员变量赋值有两种方式:
10         A:setXxx()
11         B:构造方法
12 */
13
14 class Student {
15     private String name;
16     private int age;
17
18     public Student() {
19         //System.out.println("我给了,你还给不");
20         System.out.println("这是无参构造方法");
21     }
22
23     //构造方法的重载格式
24     public Student(String name) {
25         System.out.println("这是带一个String类型的构造方法");
26         this.name = name;
27     }
28
29     public Student(int age) {
30         System.out.println("这是带一个int类型的构造方法");
31         this.age = age;
32     }
33
34     public Student(String name,int age) {
35         System.out.println("这是一个带多个参数的构造方法");
36         this.name = name;
37         this.age = age;
38     }
39
40     public void show() {
41         System.out.println(name+"---"+age);
42     }
43 }
44
45 class ConstructDemo2 {
46     public static void main(String[] args) {
47         //创建对象
48         Student s = new Student();
49         s.show();//null---0
50         System.out.println("-------------");
51
52         //创建对象2
53         Student s2 = new Student("林青霞");
54         s2.show();//林青霞---0
55         System.out.println("-------------");
56
57         //创建对象3
58         Student s3 = new Student(27);
59         s3.show();//null---27
60         System.out.println("-------------");
61
62         //创建对象4
63         Student s4 = new Student("林青霞",27);
64         s4.show();//林青霞---27
65     }
66 }

8、成员方法

 1 /*
 2     类的组成:成员变量,成员方法
 3     今天我们又加入了一个新的成员:构造方法。
 4     以后再提类的组成:
 5         成员变量
 6         构造方法
 7         成员方法
 8             根据返回值:
 9                 void类型
10                 非void类型
11             形式参数:
12                 空参方法
13                 非空参方法
14 */
15 class Student {
16     public String getString() {
17         return "helloworld";
18     }
19
20     public void show() {
21         System.out.println("show");
22     }
23
24     public void method(String name) {
25         System.out.println(name);
26     }
27
28     public String function(String s1,String s2) {
29         return s1+s2;
30     }
31 }
32
33 class StudentDemo {
34     public static void main(String[] args) {
35         //创建对象
36         Student s = new Student();
37
38         //调用无参无返回值方法
39         s.show();
40
41         //调用无参有返回值方法
42         String result = s.getString();
43         System.out.println(result);
44
45         //调用带参无返回值的方法
46         s.method("林青霞");
47
48         //调用带参带返回值的方法
49         String result2 = s.function("hello","world");
50         System.out.println(result2);
51     }
52 }

9、创建对象做了哪些事情

10、练习

 1 /*
 2     定义一个类Demo,其中定义一个求两个数据和的方法,
 3     定义一个测试了Test,进行测试。
 4
 5     变量什么时候定义为成员变量:
 6         如果这个变量是用来描述这个类的信息的,那么,该变量就应该定义为成员变量。
 7
 8     变量到底定义在哪里好呢?
 9         变量的范围是越小越好。因为能及时的被回收。
10 */
11
12 //方式1
13 /*
14 class Demo {
15     public int sum() {
16         int a = 10;
17         int b = 20;
18         int c = a + b;
19         return c;
20     }
21 }
22 */
23 //方式1满足了我们的要求,但是不好。
24 //因为参与操作的数据现在是固定的。
25
26 //方式2
27 /*
28 class Demo {
29     public int sum(int a,int b) {
30         return a + b;
31     }
32 }
33 */
34
35 //方式2可以满足我们的要求,但是呢我们学习过来面向对象的思想。
36 //我就再想,a,b可不可以定义为成员变量呢?
37 //如果可以,我们再改进一版
38 class Demo {
39     int a;
40     int b;
41
42     public int sum() {
43         return a + b;
44     }
45 }
46 //虽然这种方式可以,并且好像是符合了面向对象的思想。
47 //但是不好。
48 //因为我们曾经说过:类是一组相关的属性和行为的集合。
49 //并且类是通过事物转换过来的
50 //而类中的成员变量就是事物的属性
51 //属性是用来描述事物的
52 //同理:成员变量其实是用来描述类的。
53
54 //测试类
55 class Test {
56     public static void main(String[] args) {
57         //创建对象
58         //方式1测试
59         /*
60         Demo d = new Demo();
61         System.out.println(d.sum());
62         */
63
64         //方式2测试
65         /*
66         Demo d = new Demo();
67         int a = 10;
68         int b = 20;
69         System.out.println(d.sum(a,b));
70         */
71
72         //方式3测试
73         Demo d = new Demo();
74         d.a = 10;
75         d.b = 20;
76         System.out.println(d.sum());
77     }
78 }

11、static关键字

 1 /*
 2     定义一个人类
 3
 4     姓名和年龄都是变化的,这个我能接收,因为每个人的姓名和年龄是不同的。
 5     但是,我们现在选取的几个人都是中国人,他们的国籍是一样的。
 6     一样的国籍,我每次创建对象,在堆内存都要开辟这样的空间,
 7     我就觉得有点浪费了。怎么办呢?
 8         针对多个对象有共同的这样的成员变量值的时候,
 9         Java就提高了一个关键字来修饰:static。
10 */
11 class Person {
12     //姓名
13     String name;
14     //年龄
15     int age;
16     //国籍
17     //String country;
18     static String country;
19
20     public Person(){}
21
22     public Person(String name,int age) {
23         this.name = name;
24         this.age = age;
25     }
26
27     public Person(String name,int age,String country) {
28         this.name = name;
29         this.age = age;
30         this.country = country;
31     }
32
33     public void show() {
34         System.out.println("姓名:"+name+",年龄:"+age+",国籍:"+country);
35     }
36 }
37
38 class PersonDemo {
39     public static void main(String[] args) {
40         //创建对象1
41         Person p1 = new Person("邓丽君",16,"中国");
42         p1.show();//姓名:邓丽君,年龄:16,国籍:中国
43
44         //创建对象2
45         //Person p2 = new Person("杨幂",22,"中国");
46         //p2.show();
47         Person p2 = new Person("杨幂",22);
48         p2.show();//姓名:杨幂,年龄:22,国籍:中国
49
50         //创建对象3
51         //Person p3 = new Person("凤姐",20,"中国");
52         //p3.show();
53         Person p3 = new Person("凤姐",20);
54         p3.show();//姓名:凤姐,年龄:20,国籍:中国
55
56         p3.country = "美国";
57         p3.show();//姓名:凤姐,年龄:20,国籍:美国
58
59         p1.show();//姓名:邓丽君,年龄:16,国籍:美国
60         p2.show();//姓名:杨幂,年龄:22,国籍:美国
61     }
62 }

static内存图解:

 1 /*
 2     static的特点:(它可以修饰成员变量,还可以修饰成员方法)
 3         A:随着类的加载而加载
 4             回想main方法。
 5         B:优先于对象存在
 6         C:被类的所有对象共享
 7             举例:咱们班级的学生应该共用同一个班级编号。
 8             其实这个特点也是在告诉我们什么时候使用静态?
 9                 如果某个成员变量是被所有对象共享的,那么它就应该定义为静态的。
10             举例:
11                 饮水机(用静态修饰)
12                 水杯(不能用静态修饰)
13         D:可以通过类名调用
14             其实它本身也可以通过对象名调用。
15             推荐使用类名调用。
16
17             静态修饰的内容一般我们称其为:与类相关的,类成员
18 */
19 class Student {
20     //非静态变量
21     int num = 10;
22
23     //静态变量
24     static int num2 = 20;
25 }
26
27 class StudentDemo {
28     public static void main(String[] args) {
29         Student s = new Student();
30         System.out.println(s.num);
31
32         System.out.println(Student.num2);
33         System.out.println(s.num2);
34     }
35 }
 1 /*
 2     static关键字注意事项
 3         A:在静态方法中是没有this关键字的
 4             如何理解呢?
 5                 静态是随着类的加载而加载,this是随着对象的创建而存在。
 6                 静态比对象先存在。
 7         B:静态方法只能访问静态的成员变量和静态的成员方法
 8                 静态方法:
 9                     成员变量:只能访问静态变量
10                     成员方法:只能访问静态成员方法
11                 非静态方法:
12                     成员变量:可以是静态的,也可以是非静态的
13                     成员方法:可是是静态的成员方法,也可以是非静态的成员方法。
14             简单记:
15                 静态只能访问静态。
16 */
17 class Teacher {
18     public int num = 10;
19     public static int num2 = 20;
20
21     public void show() {
22         System.out.println(num); //隐含的告诉你访问的是成员变量
23         System.out.println(this.num); //明确的告诉你访问的是成员变量
24         System.out.println(num2);
25
26         //function();
27         //function2();
28     }
29
30     public static void method() {
31         //无法从静态上下文中引用非静态 变量 num
32         //System.out.println(num);
33         System.out.println(num2);
34
35         //无法从静态上下文中引用非静态 方法 function()
36         //function();
37         function2();
38     }
39
40     public void function() {
41
42     }
43
44     public static void function2() {
45
46     }
47 }
48
49 class TeacherDemo {
50     public static void main(String[] args) {
51         //创建对象
52         Teacher t = new Teacher();
53         t.show();
54         System.out.println("------------");
55         t.method();
56     }
57 }
时间: 05-08

Java:面向对象--封装的相关文章

Java面向对象㈠ -- 封装

Java的面向对象有三大特征:封装.继承.多态.这里主要对封装进行讲解. 封装可以理解为隐藏一个类的成员变量和成员函数,只对外提供需要提供的成员函数. Java的封装主要通过访问权限控制符:private,默认,protected,public来实现.(这四个权限访问控制符的区别网上有很多,建议读者自行搜索学习,切记要亲自练习一下!)最明显的实现就是把类的成员变量私有(private),只能通过类的成员函数来进行访问,并且此时的成员函数公有(public).这就是著名的setter/getter

Java 面向对象-封装

1.面向对象思想概述 ·面向: 基本意:面向.朝向 引申意:注重.关注 ·对象: 世间一切事物 ·面向过程思想: 面向过程思想就是把关注点放在一件事或一个活动中涉及到的步骤(也就是过程)上的思想 ·面向对象思想: -面向对象思想就是把关注点放在一件事或一个活动中涉及到的人或事物(也就是对象)上的思想 -特点:更符合人们思考习惯的思想.把复杂的事情简单话.把人们从执行者变成指挥者 -特征:封装.继承.多态 2.类与对象 描述事物从两个方面着手: 1.属性 2.行为 java中如何描述一个事物? J

Java面向对象--封装

封装:是把过程和数据包围起来,对数据的访问只能通过已定义的接口.面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治.封装的对象,这些对象通过一个受保护的接口访问其他对象.封装是一种信息隐藏技术,在java中通过关键字private实现封装.(字段私有化) 什么是封装?封装把对象的所有组成部分组合在一起,封装定义程序如何引用对象的数据,封装实际上使用方法将类的数据隐藏起来,控制用户对类的修改和访问数据的程度. 封装的例子: public class Man { //对属性的封装,一

Java面向对象----封装概念

封装 信息隐藏,隐藏对象的细节 访问修饰符 public private protected 默认 属性封装的实现 方法封装的目的(隐藏方法实现细节) package com.tanlei.newer; public class TeacherDemo { public static void main(String[] args) { teacher t=new teacher(); //t.name("zhangs"); t.setName("zhangs");

Java 面向对象-封装,继承

一:封装 特点:隐藏了实现细节,对外提供可以访问的方式. 关键字 private 将属性和方法私有化. 实现过程: 在 SetColor() 方法中可以限制调用者的输入.提高类的安全性. 二.this关键字 可以区分成员变量和局部变量 用this.变量 获取/设置 的是成员变量 注意:谁调用 this 就指向那个对象 三:继承(extends) 注意:继承只能是单继承(子类只能继承一个父类),但是父类可以被多个子类继承 格式:class 子类 extends 父类 {} 子类可以访问父类的属性和

JAVA面向对象封装(无参构造、有参构造、失血模型、重写toString)方法

//定义一个学生类public class Student {    //成员变量    private String name;    private int age;    private String address;    //无参构造方法    public Student() {        super();    }    //有参构造方法    public Student(String name, int age, String address) {        super

Java面向对象的封装

封装是Java面向对象的三大特性之一,通常我们是通过包管理机制同时对类进行封装,隐藏其内部实现细节,通常开发中不允许直接操作类中的成员属性,所以属性一般设置为私有权限private,类中一般会给出一些公共方法来让使用者通过特定方法读取或者操作里面的数据,避免误操作从而保证了数据的安全. 封装步骤一般分为3步,第一步首先修改属性的可见性,即将其设置为private:第二步创建getter/setter方法,用于获取/设置属性值,就是用来读写属性,eclipse中也提供了直接生成变量操作方法的菜单,

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

黑马程序猿——JAVA面向对象的特性:封装,继承,多态

                                       - ----------android培训.java培训.java学习型技术博客.期待与您交流!------------  一.java面向对象的特性.封装.继承.多态         封装 封装是对象和类概念的主要特性. 封装.也就是把客观事物封装成抽象的类.而且类能够把自己的数据和方法仅仅让可信的类或者对象操作,对不可信的进行信息隐藏. 继承 面向对象编程 (OOP) 语言的一个主要功能就是"继承".继承

Atitit usbQb212 oo 面向对象封装的标准化与规范解决方案java c# php js

1.1. 封装性是面象对象编程中的三大特性之一  三个基本的特性:封装.继承与多态1 1.2. 魔术方法 预定义方法2 1.3. 魔术常量(Magic constants) 预定义变量2 1.4. 适用领域 js php java c#2 1.5. 构造函数 __construct( ) vs xxxCls()3 1.6. 析构函数名称必须是__destruct( )  finally()3 1.7. 私有属性 与工友属性3 1.8. $this指针3 1.9. __autoload() 类自动