Java入门4--面向对象进阶

导包

1.同一个包下的类可以互相访问
2.不同包下的类，必须先导包才可以访问
3.如果这个类中使用不同包下的相同的类名，此时默认只能导入一个类的包，另一个类要使用全名访问

import com.fxw.student.stu;
//import com.fxw.student2.stu;

public class test {
    public static void main(String[] args) {
        //1。同一个包下的类可以互相访问

        System.out.println(user.name);

        //2.不同包下的类，必须先导包才可以访问
        stu s=new stu();

        //3.如果这个类中使用不同包下的相同的类名，此时默认只能导入一个类的包，另一个类要使用全名访问
        com.fxw.student2.stu s1=new com.fxw.student2.stu();

    }
}

权限修饰符

权限修饰符是用来控制一个成员能够被访问的范围。可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。

权限修饰符的分类和具体作用范围

有四种作用范围由小到大：
private->缺省->protected->public

private

定义私有的成员，private只能本类中访问

缺省

定义缺省修饰的成员：只能本类中、同包下其他类访问

protected

定义protected修饰的方法，本类，同包的其他类中，其他包的子类中

public

public修饰的方法，本类、同包的其他类中，其他包的子类中，其他包的无关类中

public class fu {
    //定义私有的成员，private只能本类中访问
    private void privatemethod(){
        System.out.println("private");
    }
    //定义缺省修饰的成员：只能本类中、同包下其他类访问
    void method(){
        System.out.println("缺省");
    }
    //定义protected修饰的方法，本类，同包的其他类中，其他包的子类中
    protected void protectedmethod(){
        System.out.println("protected");
    }
    //public修饰的方法，本类、同包的其他类中，其他包的子类中，其他包的无关类中
    public void publicmethod(){
        System.out.println("public");
    }

    public static void main(String[] args) {
        fu f=new fu();
        f.privatemethod();
        f.method();
        f.protectedmethod();
        f.publicmethod();
    }

}

final

作用

final关键字是最终的意思，可以修饰（类，方法，变量）
修饰类：表明该类是最终类，不能被继承。

final class Student{
}

修饰方法：表明该方法是最终方法，不能被重写。

修饰变量：表明该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）



注意：final修饰引用类型的变量，只是其地址值不能改变，但是指向对象的内容可以改变。

常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行过程中其值不能被改变。
常量的作用和好处：可以用于系统的配置信息，方便程序的维护，同时提高可读性。

执行原理
在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。
这样做的好处是让使用常量的程序的执行性能和直接使用字面量是一个作用。

命名规则
最好是全大写，用下划线连接，比如

public static final String USER_NAME="name";

常量用做信息标志和分类

枚举

枚举是Java中的一种特殊类型
枚举的作用是为了做信息的标志和信息的分类

/**
 * 枚举类
 */
public enum Season {
    //枚举类第一行默认都是罗列枚举对象的名称的。
    SPRING,SUMMER,AUTUMN,WINTER;

}

抽象类

在Java中abstract是抽象的意思，可以修饰类、成员方法。
abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

/**
 * 抽象类，一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错
 */
public abstract class Animal {
    /**
     * 抽象方法。有abstract修饰，不能写方法具体代码。
     */
    public abstract void run();
}

抽象类的基本作用是作为父类，用来被继承的。

Demo

/**
 * 父类
 */
public abstract class NormalCard {
    private String name;
    private double money;

    public abstract void pay(double money);

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

/**
 * 子类金卡
 */
public class Golden extends NormalCard{
    @Override
    public void pay(double money) {
        System.out.println("当前消费"+money);
        System.out.println("余额还剩"+this.getMoney());
        double rs=money*0.8;
        System.out.println("实际支付"+rs);
        this.setMoney(this.getMoney()-rs);
    }
}

public class test {
    public static void main(String[] args) {
        Golden g=new Golden();
        g.setMoney(1000);
        g.setName("k");
        g.pay(100);
        System.out.println("余额还剩"+g.getMoney());
    }
}

特征和注意事项

1.类有的东西，抽象类都有。
2.抽象类中可以没有抽象方法，但是有抽象方法的必须是抽象类。
3.如果一个类基础了抽象类，那么这个类必须重写玩抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
4.不能用abstract修饰变量、代码块、构造器。
5.得到了抽象方法，失去了创建对象的能力。

模版方法模式