Java基础08 封装 构造方法 静态 继承

一、封装

1.封装：对属性进行封装 提供对外访问的方法
2.体现
A.私有化属性 对属性进行封装
B.对工具类的封装 例如 加密的工具类 分页工具类…
3.好处
A.隐藏代码内部实现的细节
B.提高代码的安全性
C.提高代码的可扩展性 可复用性
4.用关键字 private 进行属性封装
可以修饰 成员变量 方法 构造 类 接口
5.使用private修饰后 只能当前类进行访问
问题：其他类不能访问成员变量
解决方案:提供两个公有的方法 set 和 get
setxxx == >用于给成员变量来进行赋值
getxxx == >用于获取成员变量的值
xxx==>属性的名称 属性的名称的首字母必须大写
6.问题: 方法的参数的名称与成员变量的名称相同时产生给变量赋值失败
原因:
就近原则:对变量进行操作的时候 获取的的是离操作的最近的变量名
在方法中 局部变量优先于成员变量
解决:通过this来获取成员变量
this==>表示的是当前对象的引用 == >就是当前对象
this.变量== >必定是成员变量
this.方法 ==>必须是成员方法

public class Student {
private String name;
private int age;
public void setName(String name) {
//是右边给左边来进行赋值
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age =age;
}
public int getAge(){
return age;
}
}

7.快捷键:alt+insert

二构造方法

1.作用
A构造方法用来实例化对象
B.构造方法用于成员变量赋值
C.所有的实例化对象都必须执行构造方法
2.1 无参构造
访问修饰符 类名(){
}
例子：public Student(){}
2.2 有参构造
访问修饰符 类名(数据类型 数据){
}
例子：public Student(String name){
this,name = name
}
3.特点:
A.构造方法的方法名必须是类名
B.构造方法没有返回值类型 但可以使用retrun; 来结束构造方法
C.构造方法不能自身进行调用 只能由系统 jvm来进行调用
4.注意点
A.一个类中没有提供任何构造方法 系统默认会提供一个无参的构造方法
B.一个类中提供了任何的构造方法 系统则不会再提供默认的无参构造方法
C.构造方法与可以实现重载
D.在实际开发中 建议提供一个有参构造 提供一个无参的构造方法
5.构造方法与set方法的区别
构造方法 只能在创建的对象的时候 给成员变量赋值一次
set方法 可以给成员变量进行多次赋值

public class Person {
private String name;
private int age;
//无参构造方法 ==>用于来实例化对象
public Person(){
System.out.println("执行了无参构造");
}
//有参构造方法 ==> 用于实例化对象的时候给成员变量来进行赋值
public Person (String name,int age){
System.out.println("执行了有参构造");
this.name =name;
this.age =age;
}
public void setName(String name){
this.name =name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age =age;
}
public int getAge(){
return age;
}
}

public class Test02 {
public static void main(String[] args) {
//Person p = new Person();
Person p = new Person("张三",18);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}

三、静态

1.关键字 static 例子:程序入口使用静态来进行修饰
2.静态修饰类 成员方法 成员变量
3.内存划分
没有静态之前：多个对象有相同的属性值 会在内存开辟多个空间 造成资源的浪费 修改麻烦

有静态之后：多个对象有相同的属性值 只需要在方法去开辟一个空间 节省内存空间 且静态的资源可以实现所有的对象进行共享 修改属性值 只需要修改一次

四、静态变量与方法

静态变量
1.静态变量是随着类的加载而加载 优先于对象先加载
2.静态的变量是存在方法区中静态区间中
3.静态变量的访问方式:
一般建议使用类名.变量名称 也可以使用对象名.变量名
静态方法
1.语法:
访问修饰符 static 返回值类型 方法的名称(参数列表) {
方法体;
retrun 返回值
}
2.静态方法只能访问静态的资源，不能访问非静态的资源（变量 方法 this）
原因：静态的资源优先对象先加载，非静态的资源还未生成所以无法访问

五、静态变量与成员变量的区别

1.所属不同
静态变量属于类变量 成员变量属于对象变量
2.存储的位置不同
静态变量存储在方法区中静态区间中 成员变量存储堆内存中
3.生命周期不同
静态变量是随着类的加载而加载 最不容易被回收
成员变量是随着对象的创建而开始 随着对象的销毁而结束
4.调用方式不用
静态变量:类名.变量名来进行调用
成员变量:对象名.变量名来进行调用

六、继承

1.在继承关系中 至少有两个类 一个父类 一个子类
2.继承：共性抽取
3.满足 is…a 的关系的时候就可以使用继承 我是你爸爸
4.关键字 extends
5.父类不能获取到子类的资源 子类可以获取父类的资源
6.
定义一个父类语法:
访问修饰 class 类名{} //就是一个普通的类
例子:public class Fu{}
定义一个子类:
访问修饰 class 类名 extends 父类的类名 {}
public class Zi extends Fu{}
员工类

package com.qf.demo02;
/**
* 父类
*/
public class Emp {
int eid;
String name;
}

老师类

package com.qf.demo02;
/**
* 老师类
*/
public class Teacher extends Emp {
public void work(){
System.out.println("授课");
}
}

助教类

package com.qf.demo02;
/**
* 助教类
*/
public class Assation extends Emp {
public void work(){
System.out.println("辅导");
}
}

测试类

package com.qf.demo02;
public class Test01 {
public static void main(String[] args) {
//实例化老师对象
Teacher t = new Teacher();
t.eid=1001;
t.name="张三";
t.work();
System.out.println(t.eid);
System.out.println(t.name);
//实例化助教对象
Assation ass = new Assation();
ass.eid=1002;
ass.name="李四";
ass.work();
System.out.println(ass.eid);
System.out.println(ass.name);
}
}

七、 继承的注意事项

1.两个不能继承
A.父类私有的资源 子类都不能继承
原因:私有的资源 只能在本类中进行访问
B.父类的构造方法 子类不能继承
子类是可以调用父类的构造方法:
调用父类的无参构造 super()
调用父类的有参构造 super(参数)
2.java只能单继承 多层继承 不可以多继承
理解:只能由一个爸爸，不能由多个爸爸，但可以有爸爸的爸爸，即爷爷，爷爷的爸爸，爷爷的爷爷（都称为简接父类）
3.一个没有继承的类即无extends修饰，其实都有一个默认的父类Object类（java自带的），所以Object类是所有子类间接的父类

八、继承访问成员变量的特点

访问成员变量的特点:
字父类变量名重名:优先访问子类的变量
字父类变量名不重名: 优先访问子类的变量 子类不存在 则向上进行查找 一直查找到Object类
如果不存在 则报错
例子
父类

package com.qf.demo03;
public class Fu extends Object{
int numFu=10;
int num=20;
}

子类

package com.qf.demo03;
public class Zi extends Fu {
int numZi=100;
// int num=200;
}

测试类

package com.qf.demo03;
public class Test {
public static void main(String[] args) {
//实例化子类的对象
Zi z = new Zi();
System.out.println(z.numZi);
System.out.println(z.numFu);
System.out.println(z.num);
//System.out.println(z.kk);
}
}

八、this与super

1.this==>表示当前对象的引用 super==>表示当前对象父类对象的引用
2.图解

加载子类之前会先加载父类，所以执行构造方法也是父类先执行

3.this与super访资源
成员变量:this ==>访问当前对象的成员变量 以及父类的成员变量
super 只能访问父类的成员变量
语法: this.变量名 super.变量名
成员方法:this == >访问当前对象的成员方法 以及访问父类的成员方法
super 只能访问父类的成员方法
语法: this.方法的名称() super.方法的名称()
构造方法: this==>访问当前对象的构造方法 super 只能访问父类的构造方法
this() 调用当前类的无参构造 this(参数列表) 调用当前类的有参构造
super() 调用当前类父类的无参构造 super(参数列表) 调用当前类父类的有参构造
总结:
this 获取当前类资源 没有则向上查找 除了构造方法
super 获取的父类的资源
4.继承访问构造方法的注意点
1.特点:
A.父类的构造方法优先于子类的构造方法先初始化完
B.如果子类没有调用父类的任何的构造方法 那么子类就默认调用父类的无参构造方法
C.如果子类调用父类的任何的构造方法 那么子类没有再调用父类默认的无参构造方法
D.如果父类只有有参构造 那么子类必须调用父类的有参构造
2.注意点:
A.this()调用当前类的构造方法 super() 调用父类的构造方法
B.this() 与super() 不能同时存在 只能出现在构造方法的第一行
C.构造方法不能递归调用
D.其它方法不能使用this() super()

例子 父类

public class Pet {
    private String name;
    private int age;
    public Pet(){

    }
    public Pet(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

子类 注意看有参构造方法处的代码

package day08;

public class Dog extends Pet{
    public Dog(){

    }
    public Dog(String name,int age){
        
        super(name, age);
    }
    public void look(){
        System.out.println("看门");
    }
}

快速生成 无参构造方法 有参构造方法 get方法 set方法
鼠标右键 选择generate… 或者快捷键alt +insert