JAVA程序开发学习日志—DAY06—2022/07/12

最新推荐文章于 2023-06-18 11:00:10 发布

MakeIPromise

最新推荐文章于 2023-06-18 11:00:10 发布

阅读量204

点赞数

文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/MakeIPromise/article/details/125740420

版权

1、当子类成员变量与父类中的成员变量同名时

2、当子类成员方法名与父类中的成员方法同名时

3、super在子类构造方法中的使用

4、为什么要去先执行父类的构造方法？

扩展知识

封装

一、封装的定义

封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。

原则：将属性隐藏起来，若需要访问某个属性，提供公共的方法对其访问。

二、封装的方式

使用private关键字对成员变量进行修饰

注：private的使用

①private是一个权限修饰符，代表最小权限。

②可以修饰成员变量和成员方法。

③被private修饰后的成员变量和成员方法，只能在本类中访问。

对需要进行赋值或者获取的成员变量，提供对应的getter和setter方法

//set方法格式：
public void setXXX(参数类型 参数名){ 
this.成员变量名=参数名；//参数名和成员变量名一致时，要使用this来区分 
}

//get方法格式：
public 返回值类型 getXXX(){ //返回值类型和成员变量类型一致 
retrun 成员变量; 
}

示例：

public class People { 
    //学生名称 
    private String name;//使用private修饰 
    //学生年龄 
    private int age; 
    //获取属性name值的方法 
    public String getName() { 
        return name; 
    }
    //设置属性name值的方法 
    public void setName(String name) { 
        this.name = name; 
    }
    //获取年龄age值的方法 
    public int getAge() { 
        return age; 
    }    
    //设置年龄age值的方法 
    public void setAge(int age) { 
        this.age = age; 
    } 
}

public class PeopleTest { 
    public static void main(String[] args) { 
        People p=new People(); 
        //p.name="kaler";不能访问！ 

        //使用setName方法对那么进行赋值 
        p.setName("kaler"); 
        //使用getName方法获取到值 
        p.getName();//"kaler" 
        //使用setAge方法对age进行赋值 
        p.setAge(100); 
} 
}

三、标准的JavaBean

1、定义：java语言在编写类的时候要遵守的一种标准规范
2、JavaBean结构：
1. public class ClassName{
  1. //成员变量
    1. //无参构造方法(必须)
      1.         //有参构造方法(依情况而定)
                //set和get方法(必须)
                //成员方法
        
                }

编写一个符合 JavaBean 规范的类：

public class Student {
    //成员变量 
    private String name; 
    private int age; 

    //无参构造方法 
    public Student(){ 
    
    }

    //有参构造方法 
    public Student(String name,int age){ 
    this.age=age; 
    this.name=name; 
    }

    //set，get方法
    public String getName() { 
        return name; 
    }
    public void setName(String name) { 
        this.name = name; 
    }
    public int getAge() { 
        return age; 
    }
    public void setAge(int age) { 
        this.age = age; 
    } 
}

继承

一、继承概述

1、概念

继承是面向对象的三大特征之一。通过继承，使得子类对象具有与父类相同的属性，相同的行为。并且子类可以直接访问父类中的非私有的属性和行为。

生活中的继承：

兔子和羊属于食草动物类,狮子和的属于食肉动物类。

食草动物和食肉动物又是属于动物关。

2、意义

多个类存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需再定义这些属性和行为，只需继承那一个类即可。
1. 例如：Cat类和Tiger类中有相同的属性，把相同的属性单独写在Animal类中。让Cat和Tiger类都去继承Animal类。
  1. 注：既然子类要继承父类中的属性，那么父类中的属性就不能用private修饰。
  2. 3、继承的设计思路
    1. ①找出几个类的共性
      1. ②抽象出父类
        ③判断是否有is-a的关系（是否有可继承的关系：狗 is—a 动物）
        
        4、继承的格式
通过extends关键字，可以声明一个类继承自另一个类
示例：如何让上述的Cat类和Tiger类去继承Animal类

//父类 
class Animal{ 
.... 
}
//子类 
class Cat extends Animal{//使用extends关键字去继承另一个类 
.... 
}
//子类 
class Tiger extends Animal{ 
... 
}

5、继承的特点

①单一性：：一个类只能继承一个父类，不能继承多个父类。（你只能有一个父亲）
1. ②传递性：类1--继承--类2，类2--继承--类3 类1同时拥有类2和类3中的公有属性。（你不仅可以用你爸爸的遗产，还可以拥有你爷爷的遗产）
优点：
①提高了代码的复用性。
②使类与类之间产生了联系，是多态的前提
缺点：
①正因为让类与类之间产生了关系，类的耦合性也增加了。当父类变化的时候，子类也不得不跟着变化

//父类：
public class Animal { 
String color; 
int age; 
public String getColor() { 
return color; 
}
public void setColor(String color) { 
this.color = color; 
}
public int getAge() { 
return age; 
}
public void setAge(int age) { 
this.age = age; 
} 
}

//子类：
public class Cat extends Animal{ 
private String catName; 
public String getCatName() { 
return catName; 
}
public void setCatName(String catName) { 
this.catName = catName; 
} 
}

//测试类：
public class Test { 
public static void main(String[] args) { 
Cat c=new Cat(); 
c.setCatName("小喵喵");//子类自身的属性 
c.setAge(5); //父类的属性 
c.setColor("橘黄"); //父类的属性 
Tiger t=new Tiger(); 
t.setTigerName("大喵喵"); //子类自身的属性 
t.setAge(6); //父类的属性 
t.setColor("白色"); //父类的属性 
} 
}

注：子类可以访问父类非私有的属性，但父类不能访问子类特有的属性。

二、super关键字

1、当子类成员变量与父类中的成员变量同名时

如果父类变量与子类变量出现同名的情况，此时在子类中访问该变量时，是访问的是子类中变量的值。如果此时需要访问到父类变量的值时，需要使用super关键字。

super的使用格式：super.父类成员变量名

2、当子类成员方法名与父类中的成员方法同名时

与上述情况一致，如果在子类中想要调用父类中同名的方法名，使用super.方法名()就可以调用父类中的方法。

3、super在子类构造方法中的使用

在创建子类对象时，默认会先去调用父类的无参构造方法，再去执行完子类本身的无参构造方法。

①怎么去调用父类无参构造方法的？

通过super();
1. 在子类的构造方法中，第一行默认有一个super()；语句，该语句就是去调用父类的无参构造方法。

②如果父类中没有无参构造方法，只有有参构造方法，如何调用？

解决1：在父类中去创建一个无参构造方法。
1. 解决2：使用super(参数列表)；根据父类有参构造方法中的参数，去传递相应的参数列表来进行调用。

4、为什么要去先执行父类的构造方法？

构造方法在创建对象的时才会去调用，所以调用了父类构造方法相当于去创建了父类的对象。问题：为什么要先去创建父类对象？
1. 之所以我们能访问到一个类中的属性，是因为我们创建了该类对象，在堆中就会开辟一个空间存储类的属性信息并且把地址赋给引用。此时我们就可以通过引用去访问类中属性了。
  1. 所以创建父类对象，相当于去堆中去开辟空间存储父类的属性信息，此时子类拿到该空间地址就可以访问了。