Java_Java

包

包的三大作用
1.区分相同名字的类
2.当类很多时,可以很好的管理类[看Java API文档]
3.控制访问范围
包基本语法
package com.hspedu;
说明:
1.package关键字,表示打包.
2.com.hspedu:表示包名
包的本质分析(原理)
包的本质实际上就是创建不同的文件夹/目录来保存类文件
常用的包
一个包下,包含很多的类,java中常用的包有:
java.lang. //lang包是基本包，默认引入,不需要再引入.
java.util. //util包，系统提供的工具包,工具类，使用Scanner
java.net. //网络包，网络开发
java.awt. //是做java的界面开发,，GUI

访问修饰符

基本介绍
java提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限(范围):
1、公开级别:用public修饰，对外公开
2、受保护级别:用protected修饰,对子类和同一个包中的类公开
3、默认级别:没有修饰符号,.向同一个包的类公开
4、私有级别:用private修饰,只有类本身可以访问,不对外公开.

使用的注意事项

修饰符可以用来修饰类中的属性，成员方法以及类
只有默认的和public才能修饰类，并且遵循上述访问权限的特点。
成员方法的访问规则和属性完全一样

封装封装介绍

封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

封装的理解和好处

1)隐藏实现细节:方法(连接数据库)<–调用(传入参数…)
2)可以对数据进行验证，保证安全合理

封装的实现步骤

封装的实现步骤(三步)
1)将属性进行私有化private【不能直接修改属性】
2)提供一个公共的(public)set方法,用于对属性判断并赋值

public void setXxx(类型参数名){ //Xxx表示某个属性
//加入数据验证的业务逻辑
属性=参数名;
}

3)提供一个公共的(public)get方法，用于获取属性的值

public 数据类型 getXxx(){ //权限判断,Xxx某个属性
return xx;
}

封装案例：一个小程序(Encapsulation01.java),不能随便查看人的年龄,工资等隐私,并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认年龄必须在1-120,年龄，工资不能直接查看，name的长度在2-6之间

package com.encap;



public class Encapsulation01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("jack");
        person.setAge(30);
        person.setSalary(30000);
        System.out.println(person.info());
        System.out.println(person.getSalary());
    }
}

class Person {
    public String name; //名字公开
    private int age;    //年龄，工资私有化
    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        //判断名字长度是否为2-6个字符
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("长度不对，默认无名氏");
            this.name = "无名氏";
        }
}

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //判断年龄是否在1-120
        if(age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄不对，默认为18");
            this.age = 18;
        }

    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //写一个方法，返回属性信息
    public String info() {
        return "信息为 name=" + name + " age=" + age + " salary=" + salary;
    }

}

封装与构造器

直接使用构造器会跳过验证，将set方法写进构造器，这样仍然可以验证

package com.encap;



public class Encapsulation01 {
    public static void main(String[] args) {
        Person smith = new Person("smith", 2000, 50000);
        System.out.println("-----smith的信息-----");
        System.out.println(smith.info());
    }
}

class Person {
    public String name; //名字公开
    private int age;    //年龄，工资私有化
    private double salary;

    //构造器
    //无参构造器
    public Person() {
    }

    //有3个属性的构造器
    public Person(String name, int age, double salary) {
        //直接使用构造器会跳过验证
//        this.name = name;
//        this.age = age;
//        this.salary = salary;
        //将set方法写进构造器，这样仍然可以验证
        setName(name);  //等价this.name
        setAge(age);
        setSalary(salary);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        //判断名字长度是否为2-6个字符
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("长度不对，默认无名氏");
            this.name = "无名氏";
        }
}

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //判断年龄是否在1-120
        if(age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄不对，默认为18");
            this.age = 18;        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //写一个方法，返回属性信息
    public String info() {
        return "信息为 name=" + name + " age=" + age + " salary=" + salary;
    }
}

继承（代码复用性）基本介绍

基本介绍
继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。
基本语法

class 子类 extends 父类{
}

1)子类就会自动拥有父类定义的属性和方法
2)父类又叫超类，基类。
3)子类又叫派生类。

继承示意图

继承使用细节

1、子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。

父类Base.java

package com.extend_;

public class Base {
    //父类，4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    public Base() { //无参构造器
        System.out.println("Base()....");
    }

    //父类提供一个public的方法，返回n4
    public int getN4() {
        return n4;
    }

    //调用私有方法test400()
    public void callTest400() {
        test400();
    }

    public void test100() {
        System.out.println("test100");
    }

    protected void test200() {
        System.out.println("test200");
    }

    void test300() {
        System.out.println("test300");
    }

    private void test400() {
        System.out.println("test400");
    }
}

子类Sub.java

package com.extend_;

public class Sub extends Base {//子类
    public Sub() {//构造器
        System.out.println("sub()....");
    }

    public void sayOK() {//子类方法
        //非私有的属性和方法可以在子类直接访问
        // 但是私有属性和方法不能在子类直接访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();错误
        //通过父类提供公共的方法访问
        System.out.println("n4=" + getN4());
        callTest400();
    }
}

2、子类必须调用父类的构造器，完成父类的初始化

父类的构造器

    public Base() { //无参构造器
        System.out.println("父类构造器Base()....");
    }

子类的构造器

public class Sub extends Base {//子类
    public Sub() {//构造器
        //super();  //不管写不写super都默认调用父类的无参构造器
        System.out.println("子类构造器sub()....");
    }

测试代码和结果

package com.extend_;

public class ExtendsDetail {
    public static void main(String[] args) {
        Sub sub = new Sub();
        //sub.sayOK();
    }
}

3、当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器；

子类构造器

    public Sub() {//构造器
        //super();  //不管写不写super都默认调用父类的无参构造器
        System.out.println("子类构造器sub()....");
    }

    public Sub(String name) {//构造器
        System.out.println("子类构造器sub(String name)....");
    }

父类构造器

    public Base() { //无参构造器
        System.out.println("父类构造器Base()....");
    }

子类构造器

    public Sub() {//构造器
        //super();  //不管写不写super都默认调用父类的无参构造器
        System.out.println("子类构造器sub()....");
    }

    public Sub(String name) {//构造器
        System.out.println("子类构造器sub(String name)....");
    }

测试代码和结果

public class ExtendsDetail {
    public static void main(String[] args) {
        Sub sub1 = new Sub();
        System.out.println("第二个对象");
        Sub sub2 = new Sub("jack");
    }
}

如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。[举例说明]

父类构造器

//    public Base() { //无参构造器
//        System.out.println("父类构造器Base()....");
//    }

    public Base(String name, int age) { //无参构造器
        System.out.println("父类构造器Base(String name, int age)....");
    }

子类构造器

    public Sub() {//构造器
        super("smith", 10);
        System.out.println("子类构造器sub()....");
    }

    public Sub(String name) {//构造器
        super("tom", 30);
        System.out.println("子类构造器sub(String name)....");
    }

4、如果希望指定去调用父类的某个构造器，则显式的调用一下: super(参数列表)
5、super在使用时，必须放在构造器第一行(super只能在构造器中使用)
6、super()和 this都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

多[多种]态[状态]

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

多态的具体体现

1、方法的多态
重写和重载就体现了多态 PolyMethod.java

package com.poly_;

public class PolyMethod {
    public static void main(String[] args) {
        //方法重载体现多态
        A a = new A();
        //这里传入不同的参数，就会调用不同的sum方法，就体现了多态
        System.out.println(a.sum(10, 20));
        System.out.println(a.sum(10, 20, 30));

        //方法重写体现多态
        B b = new B();
        a.say();
        b.say();
    }
}

class B {   //父类
    public void say() {
        System.out.println("B say() 方法被调用。。。");
    }
}

class A extends B { //子类
    public int sum(int n1, int n2) {
        return n1 + n2;
    }

    public int sum(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }

    public void say() {
        System.out.println("A say() 方法被调用。。。");
    }
}

封装与构造器

package com.encap;



public class Encapsulation01 {
    public static void main(String[] args) {
        Person smith = new Person("smith", 2000, 50000);
        System.out.println("-----smith的信息-----");
        System.out.println(smith.info());
    }
}

class Person {
    public String name; //名字公开
    private int age;    //年龄，工资私有化
    private double salary;

    //构造器
    //无参构造器
    public Person() {
    }

    //有3个属性的构造器
    public Person(String name, int age, double salary) {
//使用默认构造器会绕过验证
//        this.name = name;
//        this.age = age;
//        this.salary = salary;
        //将set方法写进构造器，这样仍然可以验证数据
        setName(name);  //等价this.name
        setAge(age);
        setSalary(salary);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        //判断名字长度是否为2-6个字符
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("长度不对，默认无名氏");
            this.name = "无名氏";
        }
}

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //判断年龄是否在1-120
        if(age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄不对，默认为18");
            this.age = 18;
        }

    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //写一个方法，返回属性信息
    public String info() {
        return "信息为 name=" + name + " age=" + age + " salary=" + salary;
    }

}

2、对象的多态(核心，困难，重点)(记住):
(1)一个对象的编译类型和运行类型可以不一致
(2)编译类型在定义对象时，就确定了，不能改变
(3)运行类型是可以变化的.
(4)编译类型看定义时=号的左边，运行类型看=号的

Animal animal = new Dog(); 【animal编译类型是Animal，运行类型=Dog)
animal = new Cat(); 【animal的运行类型变成了Cat,编译类型仍然是 Animal】

向上转型

多态的前提是:两个对象(类)存在继承关系
多态的向上转型——父类的引用指向了子类的对象

Animal.java

package com.poly_.detail_;

public class Animal {
    String name = "动物";
    int age = 10;

    public void sleep() {
        System.out.println("睡");
    }
    public void run() {
        System.out.println("跑");
    }
    public void eat() {
        System.out.println("吃");
    }
    public void show() {
        System.out.println("你好");
    }
}

Cat.java

package com.poly_.detail_;

public class Cat extends Animal{
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

PolyDetail.java

package com.poly_.detail_;



public class PolyDetail {
    public static void main(String[] args) {
        //向上转型:父类的引用指向了子类的对象
        //语法:父类类型引用名 = new子类类型();
        Animal animal = new Cat();
        Object obj = new Cat(); //可以 Object也是 Cat的父类


        //(1)可以调用父类中的所有成员(需遵守访问权限——不能调用private)
        //(2)但是不能调用子类的特有的成员(不能调用catchMouse)
        //()3因为在编译阶段，能调用哪些成员，是由编译类型来决定的
        //animal.catchMouse();错误
        //(4)最终运行效果看子类(运行类型)的具体实现，即调用方法时，按照从子类(运行类型)开始查找方法,然后调用，规则和方法调用规则一致。
        animal.eat();//猫吃鱼
        animal.run();//跑
        animal.show();//你好
        animal.sleep();//睡

        //向下转型
        Cat cat = (Cat) animal;//cat 的编译类型 Cat,运行类型是 Cat
        cat.catchMouse();//猫抓老鼠
    }
}

向下转型

语法:子类类型引用名=(子类类型)父类引用

Cat cat = (Cat) animal;//cat 的编译类型 Cat,运行类型是 Cat
只能强转父类的引用,不能强转父类的对象
要求父类的引用必须指向的是当前目标类型的对象

Dog dog = (Dog) animal;//会报错
当向下转型后,可以调用子类类型中所有的成员

Java

Java相关栏目本月热门文章