java学习中,面向对象的三大特性:封装继承多态 以及 super关键字和方法的重写(java 学习中的小记录)

Posted 王可利(Star·星星)

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java学习中,面向对象的三大特性:封装继承多态 以及 super关键字和方法的重写(java 学习中的小记录)相关的知识,希望对你有一定的参考价值。

java学习中,面向对象的三大特性:封装、继承、多态 以及 super关键字和方法的重写(java 学习中的小记录)

作者:王可利(Star·星星)

 

封装

    权限修饰符:public 公共的,private 私有的

    封装的步骤:

         1.使用private 修饰需要封装的成员变量。

         2.提供一个公开的方法设置或者访问私有的属性

             设置 通过set方法,命名格式:     set属性名();  属性的首字母要大写

             访问 通过get方法,命名格式:     get属性名();  属性的首字母要大写

 

1 //姓名设置器方法
2     public void setName(String name){
3         this.name = name;
4     }
5     //姓名访问器方法
6     public String getName(){
7         return name;
8     }

 

    代码书写的规范:java开发中一般类成员变量(属性),都是封装起来的 。

问题:是不是所有的属性都需要使用 set 和 get 方法?

    不一定,按照需求来定。

封装的作用:1. 框架  2. 工具类

封装的好处:1. 提高了数据的安全性   2. 操作简单   3. 隐藏了方法的实现。

 1 class Student{
 2     private String name;//成员变量被修饰之后只能在本类中进行访问了,私有的了。
 3     private String sex;//如果需要在外部进行访问,就需要访问方法了 set 和 get 方法。
 4     private int age;//需要收集,但是不公开,age 就只需要一个set方法就可以了
 5     
 6     //两个参数的构造方法
 7     public Student (String name,String sex){
 8         this.name=name;
 9         if(sex.equals("男")||sex.equals("女")){
10             this.sex = sex; 
11         }
12     }
13     //普通方法
14     public void study(){
15         System.out.println(name+"在学习");
16     }
17     //性别设置器方法
18     public void setSex(String sex){
19         if(sex.equals("男")||sex.equals("女")){
20             this.sex = sex;
21         }else{
22             System.out.println("你的输入不合法,请重新输入..");
23         }
24     }
25     //性别访问器方法
26     public String getSex(){
27         return sex;
28     }
29     //姓名设置器方法
30     public void setName(String name){
31         this.name = name;
32     }
33     //姓名访问器方法
34     public String getName(){
35         return name;
36     }
37     //age设置器
38     public void setAge(int age){
39         this.age = age;
40     }
41 }
42 public class fengzhuang {
43 
44     public static void main(String[] args) {
45         Student star = new Student("星星","性别");//性别  是不合法的操作
46         star.study();
47         System.out.println(star.getSex());//性别 null
48     }
49 }

 

继承

特点:继承父类的属性和方法。 特性:方法的复写(重写)  单继承(多层继承)不是多继承,c++才是多继承一个子类N个父类。

java 中的继承 和 OC中一样。

继承的作用:优化代码,减少代码的重复使用

A:B OC中继承的写法,java中如何表现继承关系,用关键字 extends 表示继承。

继承中注意事项:

1.不要为了继承而继承,千万不要为了节省代码,任何关系都继承,这样就不伦不类了。

2.父类的私有成员变量是不能够被继承的。

3.父类的构造方法是不能被继承的。

4.父类的私有方法不能被继承。

5.子类调用自己的构造方法时,会默认调用父类中的无参构造方法。

6.子类不能够继承不在一个包中默认权限的成员变量。

 

为什么会调用父类的构造方法?
子类在创建对象的时候初始化父类的变量。

 

技巧:毕竟这两个属性是从父类上面继承下来的,初始化交给父类会好一点。。

super(name,sex);//一般由自己指定(定义),如果自己指定了下面的 super()就不可以调用了。

super();//调用的是父类的构造方法

this();//调用的是自己的构造方法

 

继承代码如下:

 1 package 面向对象的三大特性;
 2 
 3 class Person{
 4     String name;//默认权限 friendly(友好的) private、public、protected
 5     String sex;
 6     Dog dog;//人和狗建立了 关联关系      整体->部分
 7     public void eat(){
 8         System.out.println(name+"在吃饭");
 9     }
10 }
11 
12 //定于学生类继承父类
13 class Student extends Person{
14     int age;
15     public void study(){
16         System.out.println(name+"在学习");
17     }
18 }
19 
20 public class jicheng {
21 
22     public static void main(String[] args) {
23         Student s = new Student();
24         s.name = "WKL";//name 自己没有 父类有
25         s.age = 20;//age 自己有的
26         System.out.println(s.name+"今年"+s.age+"岁了..");
27     }
28 }

 

关联关系(不是继承):

 1 class person{
 2     String name;
 3     String sex;
 4     Dog dog;//人和狗建立了 关联关系      整体->部分
 5     public void eat(){
 6         System.out.println(name+"在吃饭");
 7     }
 8 }
 9 
10 class Dog{
11     String name;
12     public void cry(){
13         System.out.println(name+"在叫");
14     }
15 }
16 
17 
18 public class jicheng {
19 
20     public static void main(String[] args) {
21         person star = new person();
22         star.name = "星星";
23         Dog dog = new Dog();
24         dog .name = "小白";
25         
26         star.dog = dog;//把狗这个对象 给 star的dog对象成员属性
27         /*dog.cry();*/
28         star.dog.cry();//星星的狗在叫
29         star.dog = null;
30         star.eat();
31     }
32

super关键字(指向父类对象的引用空间)

作用:

    1.当子类和父类存在同名的成员变量时,会先在子类里面找默认有一个this(this.name),可以通过super来调用父类的成员变量(super.name)。

    2.super可以用来调用父类的构造方法。

super使用的注意的地方:

    1.用super调用父类构造方法,必须是构造方法中的第一个语句。

    2.super只能出现在子类的方法或者构造方法中。

    3.super 和 this 不能够同时调用构造方法。(因为this也是在构造方法的第一个语句)

总结:super 和 this 的区别:

   1.代表的事物不一样:

        this:代表所属方法的调用者对象。

        super:代表父类对象的引用空间。

    2.使用前提不一致:

        this:在非继承的条件下也可以使用。

        super:只能在继承的条件下才能使用。

     3.调用构造方法:

         this:调用本类的构造方法。

         super:调用的父类的构造方法

方法的复写(重写)

作用:父类的方法满足不了子类的实现,这个时候就需要通过复写(重写)方法再实现父类的行为。

方法的复写使用注意事项:

    1.方法重写的时候,必须存在继承关系。

    2.方法重写的时候,方法名和形式参数 必须跟父类是一致的

    3.方法重写的时候,子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected < public,friendly < public )

    4.方法重写的时候,子类的返回值类型必须小于或者等于父类的返回值类型。(  子类 < 父类 )  数据类型没有明确的上下级关系

    5.方法重写的时候,子类的异常类型要小于或者等于父类的异常类型。

方法的重载:方法名是一样的,只是参数列表的个数,类型,顺序不一样。

 

多态(一个对象同种类型不同表现形态

父类的引用类型变量指向子类的对象。

接口的引用类型变量指向类的实现。

多态使用注意事项:

    1.多态情况下,父类 和 子类存在同名的成员变量,无论是静态的还是非静态的变量,默认访问的是父类中的成员变量。

    2.多态情况下,父类 和 子类存在同名的非静态方法,访问的是子类的非静态方法。

    3.多态情况下,父类 和子类存在同名的静态方法,访问的是父类的静态方法。

    4.多态情况下,不能访问子类特有的属性、方法。

    5.多态满足的条件:必须要有继承关系。

总结:多态情况下,子类 和 父类如果存在同名的成员,访问的都是父类,除了同名的非静态变量访问的才是子类。

java 编译器编译原理导致的。

编译看左边,运行不一定看右边。

编译看左边的意思:java 编译器在编译的时候会检测引用类型中含有指定的成员,如果没有就会报错。子类的成员是特有的,父类的没有的,所以他是找不到的。

 1 package study;
 2 
 3 abstract class Animal{
 4     String name;
 5     static String color = "动物色";
 6     
 7     public abstract void run();
 8     
 9     public void eat(){
10         System.out.println("这个是父类中的方法");
11     }
12 } 
13 
14 class Dog extends Animal{
15     static String color = "黄色";
16     //重写父类中的方法
17     public void run(){
18         System.out.println(name+"用四条腿在跑步");
19     }
20     //重写父类中的eat方法
21     public void eat(){
22         System.out.println("这个是子类中的方法");
23     }
24 }
25 
26 class Fish extends Animal{
27     
28     //重写父类的方法
29     public void run(){
30         System.out.println(name+"在自由自在地游泳");
31     }
32 }
33 
34 public class star {
35     public static void main(String[] args) {
36         
37        Animal a = new Dog();//Animal 指针指向 Dog
38        a.name = "小黄";
39        a.run();
40        
41        a.eat();
42        System.out.println(a.color);
43        
44 //       a = new Fish();//Animal 指针指向 Fish
45 //       a.name = "小黄";
46 //       a.run();   
47     }
48 }

多态使用的场景:

    1.多态可以用于做形式参数,可以让方法接收更多的类型。

    2.多态用于返回类型,可以返回更多的数据类型。

问题:想用子类的类型接收回来,这个时候就需要用到强制转换。

         如:Animal  a = new Dog(); //多态

               Dog  d = (Dog)a; 

多态的另一种实现:

    实现关系下的多态:

        接口  变量名  = new  实现类();

    接口是不能创建对象的,所以就使用实现这个接口的类来创建对象

    我返回的是圆的对象,不能用圆的引用变量来接收:返回的图形 -> 圆的父类

    基本数据类型的转换:大的数据 -> 小的接收(强制转换)

 1 package study;
 2 
 3 //需求1:定义一个方法可以接收任意类型 的图形对象,求面积和周长。
 4 //需求2:定于一个方法可以返回任意类型的图形。
 5 abstract class MyShape{
 6     //定义两个方法求面积和周长。
 7     public abstract void getArea();
 8     public abstract void getLength();
 9 }
10 
11 class Circle extends MyShape{
12     int r;
13     final double PI = 3.14;
14     
15     //重写父类中的方法
16     public void getArea(){
17         System.out.println("圆的面积");
18     }
19     public void getLength(){
20         System.out.println("圆的周长");
21     }
22 }
23 
24 class Rect extends MyShape{
25     
26     public void getArea(){
27         System.out.println("矩形的面积");
28     }
29     public void getLength(){
30         System.out.println("矩形的周长");
31     }
32 }
33 
34 public class star {
35     public static void main(String[] args) {
36         
37         //需求1:定义一个方法可以接收任意类型 的图形对象,求面积和周长。
38         getAreaAndLength(new Circle());
39         getAreaAndLength(new Rect());
40         
41         //需求2:定于一个方法可以返回任意类型的图
42         MyShape a = getMyShape(0);//
43         /*getAreaAndLength(a);//在这里拿到的是哪个型就计算哪个的面积和周长。*/    
44         
45         Circle c = (Circle)a;//引用数据类型的强制转换
46         getAreaAndLength(c);//在这里拿到的是哪个型就计算哪个的面积和周长。
47     }
48     
49     public static void getAreaAndLength(MyShape ms){//这个参数拿到的是父类的对象,凡是属于这个父类的都可以使用这个方法。如果是圆就只能接收圆的
50         ms.getArea();
51         ms.getLength();
52     }
53     
54     public static MyShape getMyShape(int i){
55         if (i == 0) {
56             return new Circle();//
57         }else if (i == 1) {
58             return new Rect();//矩形
59         }
60         return null;
61     }
62 }

以上是关于java学习中,面向对象的三大特性:封装继承多态 以及 super关键字和方法的重写(java 学习中的小记录)的主要内容,如果未能解决你的问题,请参考以下文章

java中面向对象的三大特性:封装继承多态和关键字instanceof

面向对象编程三大特性-封装、继承、多态

Java面向对象三大特性(封装继承多态)

JAVA基础——面向对象三大特性:封装继承多态

Java中面向对象的三大特征是啥?

Python学习之旅---多态(类的相关知识,面向对象三大特性:继承-多态-封装)