java封装、重载.doc

封装

为什么要使用封装?

隐藏类中的属性和实现细节,对外只提供公共的访问方式

安全性
可以使用流程控制语句对值的限制
只能用我提供的访问方式来访问
this :表示本类对象
作用:

区别成员变量和局部变量同名
调用本类构造器:
注意:位置必须写在构造器的第一行代码处;必须写在 构造器中

set get 访问器:一个属性对应两个访问器;
alt+shift+s可以快捷生成get,set访问器

//封装示例代码
package day14;

class Book{
    private String title;
    private int pageNum;

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        if(pageNum < 200){
            this.pageNum = pageNum;
        }else{
            System.out.println("输入页数错误");
        }
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title){
        this.title = title;
    }

    public void show (){
        System.out.println(title + pageNum);
    }
}
public class Ex1 {

    public static void main(String[] args) {
        Book book = new Book();
        book.setPageNum(300);
        book.setTitle("平凡的世界");
        book.show();

    }

}

重载

方法重载

通常在一个类中,方法名相同,参数裂变不同(类型、个数、顺序),与返回值无关

作用:方便记忆!

//重载示例
package day14;

class Test{
    public void f(int n){
        System.out.println("int");
    }

    public void f(byte n){
        System.out.println("byte");
    }

    public void f(short n){
        System.out.println("short");
    }
    public void f(long n){
        System.out.println("Long");
    }

    public void f(double n1 ,double n2){
        System.out.println("两个double");
    }

    //----------------------------------   
    //不能重载:原因:因为可变参数就是数组
    public void f(int ...n){
        System.out.println("可变参数");
    }

//  public void f(int [] n){
//      System.out.println("数组");
//  }

    //-----------------------------
    //优先调用int。原因:为了代码的兼容
    public void method(int ...n){
        System.out.println("可变参数");
    }

    public void method(int n){
        System.out.println("int");
    }

    //-----------------------------------
    public void func(Test  ...n){
        System.out.println("Test");
    }
    public void func(String  ...s){
        System.out.println("String");
    }
}

public class Ex2 {

    public static void main(String[] args) {
        Test t = new Test();
        t.f(11);
        t.f((byte)11);
        t.f((short)11);
        t.f(11L);
        t.f(11, 22);

        t.method(11);

        Test t1 = null;
        String str = "null";

        //传参时,值对于多个方法的参数都适用就会出错
        //t.func(null);
        t.func(t1);
        t.func(str);

    }

}

构造方法

格式:

访问修饰符 构造方法名字(参数列表){

//初始化代码

}

作用:初始化对象。(给对象 拥有的 成员变量赋初始值);创建完对象,值都有了

注意:构造方法的名称必须与类名一致; 只要显示定义了构造器,系统默认构造器就不存在了

分类:

1.默认构造器

我们没有显示的定义构造器,那么系统才会自动分配一个默认的构造器
这个构造器无参数,访问权限 和 定义的类一致
1
2
3
2.带参构造器

3.无参构造器

构造器方法 和 普通方法的区别;

构造器 是 完成对象 的初始化
普通方法 是 完成某个特定的功能

构造器只有在 new 创建对象的时候才能调用
普通方法随时想用,就可以用对象调用

构造器和访问器的区别

构造器在创建new对象时进行初始化,可以一次性给所有的属性赋值
访问器 在创建对象置后,逐个调用setter访问器赋值

构造器只能完成 创建对象时初始化
创建对象后 想 修改 对象 的值,需要使用 setter 访问器

创建对象 后,访问(获得)属性的值,需要使用getter访问器

//构造器示例
package day14;
class Teacher{
    private String name;
    private int age;

    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;
    }

    public void show(){
        System.out.println(name + age);
    }

    //访问权限和类相同
/*  Teacher(){

    }*/
    //带参构造器
    Teacher(String name , int age){
        this.name = name;
        this.age = age;
    }

    //显示定义一个构造器
    Teacher(){
        this.name = "杨康";
        this.age = 33;
    }
}

public class Ex4 {

    public static void main(String[] args) {
        //                    调用构造方法
        Teacher guojing = new Teacher();
        guojing.show();
        guojing.setName("郭靖");
        guojing.setAge(22);
        guojing.show();
        Teacher zhangsan = new Teacher("张三",55);
        zhangsan.show();

    }

}

构造器调用

this() ; 调用本类的无参构造器,位置必须写在构造器的第一行代码处

也可以调用带参构造器,系统会根据参数个数去找

使用构造器的好处:可以一次性定义相同的属性

构造块

作用:多个构造方法重载时

定义:在类中定义

执行:在创建new对象时,先执行构造快,后执行构造器

//构造器调用示例代码
package day14;
class Role{
    private String name;
    private String sex;
    private int age;
    private String job;
    private String address;
    //构造块,在构造器之前,先被执行;没有传实参时均默认为内蒙古
    {
        this.address = "内蒙古";
    }

    public Role(){
        this.name = "匿名";
    }

    public Role(String job){
        //调用无参构造
        this();
        this.job = job;
    }

    public Role(String sex,int age ,String job){
        this.sex = sex;
        this.age = age;
        this.job = job;
    }
    public Role(String name,String sex,int age ,String job,String address){
        //调用有参构造
    //  this("女",99,"会计");
        this(sex,age,job);
        this.name = name;
        //this.sex = sex;
        //this.age = age;
        //this.job = job;
        this.address = address;
    }
    public void show(){
        System.out.println(name + sex + age + job + address);
    }
}
public class Ex5 {

    public static void main(String[] args) {
        Role qiaofeng = new Role ("乔峰","男",22,"丐帮帮主","浙江");//改变了构造块的内容
        qiaofeng.show();
        Role monk = new Role("男",88,"扫地");
        monk.show();
        Role killer = new Role("杀手");
        killer.show();
        Role person = new Role();
        person.show();

    }

}

对象(实例成员)初始化

默认初始化
声明处初始化
构造块初始化
2.3看代码中的位置
构造器
程序包

定义:组织类和接口

package 包名[.子包]

包名命名规范:所有字母都小写

作用:

文件夹的作用,管理文件
解决文件命名冲突的问题
更好地保护类和类中的成员
注意:
1. 同一个项目下,包名不能相同
2. 命名习惯:一般域名反转.部门名字.项目名

使用

同一包下的类,可以直接访问
不同类下的包:导包import,或者使用完全命名的方式(b.B = new b.B();调用b包下的B类
使用注意:
1. 包名 .*不会导入子包的类型
2. 两个包下的类名相同,必须用完全限定命名的方式使用

评论

暂无评论