11、封装

超、凢脫俗 2024-04-01 15:04 36阅读 0赞

1、封装定义:封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的操作[方法],才能对数据进行操作。(类似于操作电视机)

2、优点:

(1)隐藏实现细节(方法调用)

(2)可以对数据进行验证,保证安全合理

3、封装的实现步骤(三步曲):

  1. //1、将属性进行私有化[不能直接修改属性]
  2. //2、提供一个公共的set方法,用于对属性判断并赋值
  3. public void setXxx(类型 参数名){
  4. //加入数据验证的业务逻辑
  5. 属性=参数名;
  6. }
  7. //3、提供一个公共的get方法,用于获取属性的值
  8. public XX getXxx(){//权限判断
  9. return xx;
  10. }

4、入门

  1. /*题目:
  2. 不能随便查看人的年龄、工资等隐私,并对设置的年龄进行合理的验证(1-120),
  3. 否则给默认年龄。name的长度在2-6字符之间*/
  4. package package20221105;
  5. public class Encapsulation {
  6. public static void main(String[] args) {
  7. Person person=new Person();
  8. person.setName("jack");
  9. person.setAge(30);
  10. person.setSalary(30000);
  11. System.out.println(person.info());
  12. //自己使用构造器指定属性
  13. Person smith=new Person("smith",20,50000);
  14. System.out.println("smith:");
  15. System.out.println(smith.info());
  16. }
  17. }
  18. class Person{
  19. public String name;
  20. private int age;
  21. private double salary;
  22. public Person() {
  23. }
  24. //使用快捷键Alt+insert,选择“构造函数”,选择三个成员变量,快速生成构造器
  25. public Person(String name, int age, double salary) {
  26. //this.name = name;
  27. //this.age = age;
  28. //this.salary = salary;
  29. //可以将set方法写在构造器中,下面三行相当于上面三行代码的作用,这样仍然可以验证
  30. setName(name);
  31. setAge(age);
  32. setSalary(salary);
  33. }
  34. //自动生成get和set方法的快捷键Alt+insert,选择“Getter和Setter”,
  35. // 选中三个成员变量,即可自动生成
  36. public String getName() {
  37. return name;
  38. }
  39. public void setName(String name) {
  40. //加入对数据的校验,增加了业务逻辑
  41. if(name.length()>=2&&name.length()<=6){
  42. this.name=name;
  43. }else{
  44. System.out.println("名字的长度不对,需要(2-6)字符,默认名字:无名氏");
  45. this.name="无名氏";
  46. }
  47. }
  48. public int getAge() {
  49. return age;
  50. }
  51. public void setAge(int age) {
  52. if(age>=1&&age<=120){
  53. this.age=age;
  54. }else {
  55. System.out.println("年龄不对,需要在(1-120),给默认年龄18");
  56. this.age = 18;
  57. }
  58. }
  59. public double getSalary() {
  60. //在此增加对当前对象的权限判断
  61. return salary;
  62. }
  63. public void setSalary(double salary) {
  64. this.salary = salary;
  65. }
  66. //写一个方法,返回属性信息
  67. public String info(){
  68. return "name="+name+" age="+age+" salary="+salary;
  69. }
  70. }
  71. /*输出:
  72. name=jack age=30 salary=30000.0
  73. smith:
  74. name=smith age=20 salary=50000.0*/

5、练习题

  1. /*题目:定义两个类:Account和AccountTest类体会java的封装性
  2. 1、Account类要求具有属性:姓名(长度为2、3、4位)、余额(必须>20)、
  3. 密码(必须是六位),如果不满足,则给出提示信息,并给默认值
  4. 2、通过setXxx的方法给Account的属性赋值
  5. 3、在AccountTest中测试*/
  6. //我的答案:
  7. package package20221105;
  8. public class AccountTest {
  9. public static void main(String[] args) {
  10. Account person2=new Account("smith",30,123456);
  11. person2.info();
  12. }
  13. }
  14. class Account{
  15. String name;
  16. double ban;
  17. int pin;
  18. public Account(String name, double ban, int pin) {
  19. setName(name);
  20. setBan(ban);
  21. setPin(pin);
  22. }
  23. public String getName() {
  24. return name;
  25. }
  26. public void setName(String name) {
  27. if(4>=name.length()&&name.length()>=2){
  28. this.name=name;
  29. }else{
  30. System.out.println( "名字输入错误,默认名字为无名氏");
  31. this.name = "无名氏";
  32. }
  33. }
  34. public double getBan() {
  35. return ban;
  36. }
  37. public void setBan(double ban) {
  38. if(ban<=20) {
  39. System.out.println( "余额必须>20,默认值为29");
  40. this.ban = 29;
  41. }else{
  42. this.ban=ban;
  43. }
  44. }
  45. public int getPin() {
  46. return pin;
  47. }
  48. public void setPin(int pin) {
  49. if(pin.length()!=6) {//密码应该设置为String型
  50. System.out.println( "密码错误,必须为6位,默认密码为123456");
  51. this.pin = 123456;
  52. }else{
  53. this.pin=pin;
  54. }
  55. }
  56. //打印信息
  57. public void info(){
  58. System.out.println("name="+name+" ban="+ban+" pin="+pin);
  59. }
  60. }
  61. //老师的答案:
  62. package package20221105;
  63. public class AccountTest {
  64. public static void main(String[] args) {
  65. Account person2=new Account();
  66. person2.setName("smith");
  67. person2.setBalance(30);
  68. person2.setPwd("123456");
  69. person2.info();
  70. }
  71. }
  72. class Account{
  73. private String name;
  74. private double balance;
  75. private String pwd;
  76. //提供两个构造器
  77. //一个无参构造器
  78. public Account(){
  79. }
  80. //一个有参构造器
  81. public Account(String name, double balance, String pwd) {
  82. this.setName(name);
  83. this.setBalance(balance);
  84. this.setPwd(pwd);
  85. }
  86. public String getName() {
  87. return name;
  88. }
  89. public void setName(String name) {
  90. if(4>=name.length()&&name.length()>=2){
  91. this.name=name;
  92. }else{
  93. System.out.println( "名字要求(长度为2位、3位或4位),默认名字为无名氏");
  94. this.name = "无名氏";
  95. }
  96. }
  97. public double getBalance() {
  98. return balance;
  99. }
  100. public void setBalance(double balance) {
  101. if(balance>20) {
  102. this.balance = balance;
  103. }else{
  104. System.out.println( "余额(必须>20),默认值为0");
  105. this.balance = 0;
  106. }
  107. }
  108. public String getPwd() {
  109. return pwd;
  110. }
  111. public void setPwd(String pwd) {
  112. if(pwd.length()!=6) {
  113. System.out.println( "密码(必须为6位),默认密码为000000");
  114. this.pwd = "000000";
  115. }else{
  116. this.pwd = pwd;
  117. }
  118. }
  119. //打印信息
  120. public void info(){
  121. System.out.println("name="+name+" balance="+ balance +" pwd="+ pwd);
  122. }
  123. }
  124. /*输出:
  125. 名字要求(长度为2位、3位或4位),默认名字为无名氏
  126. name=无名氏 balance=30.0 pwd=123456
  127. */

发表评论

表情:
评论列表 (有 0 条评论,36人围观)

还没有评论,来说两句吧...

相关阅读

    相关 11封装

    1、封装定义:封装(encapsulation)就是把抽象出的数据\[属性\]和对数据的操作\[方法\]封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的操作\[方法

    相关 封装

    封装 . Java中封装的概念 将一系列相关事物共同的属性和行为提取出来,放到一个类中,隐藏对象的属性和实现细节(private),仅对外提供公共的访问方式(ge

    相关 封装

    封装 概念 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提高的方法来实现对隐藏信息的操作和访问; 好处: 1.只能通过规定的方法访问数据; 2.隐藏

    相关 封装

    封装:指隐藏对象的属性和实现细节,金对外提供公共的访问方式 封装的好处是: 提高重用性,提高安全性,便于使用,可以将变化隔离 封装原则: 将不需要对外提供的内容隐藏,把属性

    相关 封装

    一、封装的概念 封装,即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别;将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是