Java 继承 封装 多态

柔情只为你懂 2022-05-20 06:24 383阅读 0赞
  1. JAVA 面向对象 Day 03 7/13

封装提高安全

封装步骤:1.作用域设置为:private

  1. 设置属性的get/set 方法

Get 方法作用:访问属性

Set 方法作用给属性赋值

3.通过get/set方法访问或者给属性赋值。

  1. class frame{
  2. privateintage;
  3. private String name; //封装
  4. publicint getAge(){
  5. returnage;
  6. }
  7. publicvoid setAge(int age) {
  8. this.age = age;
  9. }
  10. public String getName() {
  11. returnname;
  12. }
  13. publicvoidsetName(String name) {
  14. this.name = name;
  15. }
  16. }

-—————————————————————————————

Mismatch 不 匹配

方法重载:在同一个类中,方法名相同,参数的个数和类型不同。构造方法亦可重载

类的构造函数无参构造函数如果没有的话,系统会默认提供。

Alt + shift+S 快捷创建有参无参构造函数

类成员的访问修饰符:







































作用域

修饰符

同一个类中

同一个包中

子类中

任何地方

private

可以

不可以

不可以

不可以

默认修饰符

可以

可以

不可以

不可以

Protected

可以

可以

可以

不可以

Public

可以

可以

可以

可以

This 使用类里面的值 object 是所有类的父类

多态: 同一个引用类型使用不同的实例而执行不同操作,方法重写是实现多态的基础

参数是父类,传过来的传过来的是子类的实例对象

多态根据不同类型的参数,执行不同的操作

重写 (override)

方法重载(overload)

重载与重写的区别:

1、重载:
方法名相同,参数列表不同
2、重写:
也叫覆盖,指在子类中定义一个与父类中方法同名同参数列表的方法。因为子类会继承父类的方法,而重写就是将从父类继承过来的方法重新定义一次,重新填写方法中的代码。

继承 extends java中只支持单根继承,即一个类只能有一个父类

  1. package dierzhou;
  2. class Animal{
  3. String name;
  4. int love;
  5. int health;
  6. public String getName() {
  7. return name;
  8. }
  9. public int getLove() {
  10. return love;
  11. }
  12. public int getHealth() {
  13. return health;
  14. }
  15. public void toStr(){
  16. }
  17. }
  18. class qiEr extends Animal{
  19. public void qiEr(int n) {
  20. if (n==0){
  21. System.out.println(name+"是一个"+"酷酷的Q仔");
  22. }else{
  23. System.out.println(name+"是一个"+"帅帅的Q仔");
  24. }
  25. }
  26. @Override //重写
  27. public void toStr() {
  28. // TODO Auto-generated method stub
  29. super.toStr();
  30. if(this.health<60){
  31. System.out.println("吃药打针后");
  32. this.health=70;
  33. }
  34. }
  35. }
  36. class Dog extends Animal{
  37. String strain;
  38. public String getStrain() {
  39. return strain;
  40. }
  41. public void Dog(int n) {
  42. if (n==0){
  43. System.out.println(name+"是一个"+"酷酷的雪纳瑞");
  44. }else{
  45. System.out.println(name+"是一个"+"聪明的拉布拉多犬");
  46. }
  47. }
  48. @Override //重写
  49. public void toStr() {
  50. // TODO Auto-generated method stub
  51. if(this.health<60){
  52. System.out.println("吃药打针后");
  53. this.health=70;
  54. }
  55. }
  56. }
  57. //多态
  58. class Master{
  59. public void cure(Animal animal){
  60. animal.toStr();
  61. }
  62. }
  63. public class tste {
  64. public static void main(String[] args) {
  65. // TODO Auto-generated method stub
  66. //程序开始时间
  67. long start=System.currentTimeMillis();
  68. qiEr q=new qiEr();
  69. Master m=new Master(); //对象实例化
  70. q.name="小白";
  71. q.love=100;
  72. q.health=49;
  73. System.out.println("我的名字叫:"+q.getName());
  74. System.out.println("生病中我的健康状态是:"+q.getHealth());
  75. m.cure(q);
  76. System.out.println("看病后中我的健康状态是:"+q.getHealth());
  77. // System.out.println("我的名字叫:"+q.getName()+"\t 我的健康状态是:"+q.getHealth()+"\t我和主人的亲密度是:"+q.love);
  78. System.out.println("我和主人的亲密度是:"+q.love);
  79. q.qiEr(1);
  80. Dog d=new Dog();
  81. d.name="小虎";
  82. d.love=100;
  83. d.health=50;
  84. d.strain="拉布拉多";
  85. System.out.println("我的名字叫:"+d.getName()+"\t 我的健康状态是:"+d.getHealth()+"\t我和主人的亲密度是:"+d.love+"\t我的类型为:"+d.strain);
  86. m.cure(d);
  87. System.out.println("我的健康状态是:"+d.getHealth());
  88. d.Dog(2);;
  89. long end=System.currentTimeMillis(); //程序结束时间
  90. System.out.println("程序运行时间"+(end-start)+"ms");
  91. }
  92. }

70

发表评论

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

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

相关阅读

    相关 Java继承 封装

    继承概念:简单说就是一个类使用extends来关联另一个已存在的类(API中的或者自己写的),Java继承是面向对象的最显著的特征之一并且一个类只能单继承(只能继承一个 类)不

    相关 封装继承

    封装: 含义: 1. java中,对象就是一个封装体。 2. 把对象的属性和服务结合成一个独立的单位,并尽可能隐蔽对象的内部细节(尤其是私有数据) 3. 目的

    相关 封装继承

    一、封装:   封装是实现面向对象程序设计的第一步,封装就是将数据或函数等集合在一个个的单元中(我们称之为类)。被封装的对象通常被称为抽象数据类型。   封装的意义:
  

    相关 继承封装

    一、封装:   封装是实现面向对象程序设计的第一步,封装就是将数据或函数等集合在一个个的单元中(我们称之为类)。被封装的对象通常被称为抽象数据类型。 封装的意义:   

    相关 继承 封装

    1.继承的好处:方便我们优化代码,提高扩展性 继承的使用: 父类的引用指向了子类的对象,如果用父类的这个引用指向了多个子类的对象,那么这个引用就可以调用这多个子类从父类

    相关 封装继承

    面向对象的三个基本特征 面向对象的三个基本特征是:封装、继承、多态。其中,封装 可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代