Java基础：包

最新推荐文章于 2024-10-06 15:28:17 发布

ACBYCL

最新推荐文章于 2024-10-06 15:28:17 发布

阅读量728

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/ACBYCL/article/details/126221710

版权

一 .什么是包

在这里插入图片描述

二.权限访问符

在这里插入图片描述

package Test;

public class Test {
    /**
     * 1.定义私有的成员：privae只能本类中访问
     */
    private void privateMethod(){
        System.out.println("---private---");
    }

    /**
     * 2.定义缺省修饰的成员：只能本类中，同包下其他类访问(包访问权限)
     */
    void method(){
        System.out.println("---缺省---");
    }

    /**
     * 3.protected 修饰的方法：本类，同包的其他类中，其他包的子类中。
     */
    protected void protectedMethod(){
        System.out.println("---protected---");
    }

    /**
     * 4.public 修饰的方法：本类，同包的其他类中，其他包的子类中，其他包的无关类中
     */
    public void publicMethod(){
        System.out.println("---public---");
    }

    public static void main(String[] args) {
        Test t=new Test();
        t.method();
        t.privateMethod();
        t.protectedMethod();
        t.publicMethod();
    }
}

三.final的作用

在这里插入图片描述

Test2.java

package Test;

public class Test2 {

    /**
     * 二：修饰静态成员变量(public static final常量)
     */
    public static final String schoolName="黑马";

    /**
     * 三：修饰实例成员变量(几乎不用)
     */
    private final String name="猪刚烈";

    public static void main(String[] args) {
//        目标：理解final修饰变量的作用：总规则：变量有且仅能被赋值一次
//        变量有几种：
//          1。局部变量
//          2.成员变量
//               ----实例成员变量
//               ----静态成员变量
        final double rate=3.14;
//        rate=3.19;//第二次赋值了
        bug(0.8);

//        schoolName="黑马程序员";//第二次赋值了

        Test2 t=new Test2();
        System.out.println(t.name);
//        t.name="天蓬元帅";//第二次赋值了

//        注意：final修饰引用类型的变量，其地址值不能改变，但是指向的对象的内容可以改变的
        final Teacher t2=new Teacher("学习，授课，吹吹水");
//        t2=null;//第二次赋值了
        System.out.println(t2.getHobby());
        t2.setHobby("运动");
        System.out.println(t2.getHobby());

    }

    public static void bug(final double z) {
//        z=0.1;//第二次赋值了
    }
}

class Teacher{
    private String hobby;

    public Teacher(String hobby) {
        this.hobby = hobby;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//        目标：记住final的语法
//        1.final修饰类，类不能被继承
//        2.final修饰方法，方法不能被重写
//        3.final修饰变量，总规则：变量有且仅能被赋值一次

    }
}

class Student extends People {
    @Override
    public void eat(){
        System.out.println("学生吃的很多");
    }
}
class People{
    public void eat(){
        System.out.println("人都要吃东西");
    }
}

四.常量

五.枚举

在这里插入图片描述

六.抽象类

在这里插入图片描述

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//        目标：学习以下抽象类的基本使用：做父类，被继承，重写抽象方法
        GoldCard c=new GoldCard();
        c.setMoney(1000);
        c.setUserName("dlei");

        c.pay(300);
        System.out.println("剩余："+c.getMoney());
    }
}

Gard.java

package Test;


public abstract class Card {
    private String userName;
    private double money;

    /**
     * 定义一个支付方法：表示卡片可以支付
     * 抽象方法
     */
    public abstract void pay(double money);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

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

GoldCard.java

package Test;

public class GoldCard extends Card{

    @Override
    public void pay(double money2) {
        System.out.println("您当前消费："+money2);
        System.out.println("您卡片当前余额是："+getMoney());
//        优惠价：
        double rs=money2*0.8;
        System.out.println(getUserName()+":您实际支付："+rs);
//        更新账户余额
        setMoney(getMoney()-rs);

    }
}

特点

在这里插入图片描述

package Test;


public class Test {
//    目标：理解抽象类的特征和注意事项
//    1.类有的东西，抽象类都有
//    2.抽象类中可以没有抽象方法，但是有抽象方法的必须是抽象类
//    3.一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类

//    4.抽象类不能创建对象，为什么？？
//    反证法：假如抽象类可以创建对象，
//    Animal a =new Animal();
//    a.run();//run方法连方法体都没有，因此抽象类不能创建对象

//    Card c=new Card();//不行的，抽象类不能创建对象(这个观点不能动摇)


}

abstract class Card{
    private String name;

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name=name;
    }
}
abstract class Cat extends Animal{
    @Override
    public void run(){

    }
}

abstract class Animal{
    public abstract void run();
    public abstract void eat();
}

abstract与final的关系

在这里插入图片描述

案例一

在这里插入图片描述

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//        目标：理解模板方法模式的思想和使用步骤
        StudentMiddle s=new StudentMiddle();
        s.write();

        StudentChild s2=new StudentChild();
        s2.write();


    }
}

Student.java

package Test;

public abstract class Student {
//    final 防止方法重写
    public final void write(){
        System.out.println("\t\t\t\t《我的爸爸》");
        System.out.println("你的爸爸是啥样,来说说：");
//        正文部分(每个子类都要写的，每个子类写的情况不一样
//        因此，模板方法把正文部分定义成抽象方法，交给
//        具体的子类来完成)
        System.out.println(writeMain());

        System.out.println("我的爸爸简直太好了");
    }
    public abstract String writeMain();
}

StudentChild.java

package Test;

public class StudentChild extends Student{
    @Override
    public String writeMain(){
        return "的爸爸太牛b了，他总是买东西给我吃";
    }

}

StudentMiddle.java

package Test;

public class StudentMiddle extends Student{
    @Override
    public String writeMain(){
        return "我的爸爸很牛，开车都不看红绿灯，"+"下辈子我还要做他儿子";
    }
}

展示结果

"C:\Program Files\Microsoft\jdk-11.0.12.7-hotspot\bin\java.exe" "-javaagent:D:\JAVA\I
				《我的爸爸》
你的爸爸是啥样,来说说：
我的爸爸很牛，开车都不看红绿灯，下辈子我还要做他儿子
我的爸爸简直太好了
				《我的爸爸》
你的爸爸是啥样,来说说：
的爸爸太牛b了，他总是买东西给我吃
我的爸爸简直太好了

进程已结束,退出代码0

七.接口

什么是接口

package Test;

//申明了一个接口：体现一种规范，规范一定是公开的
public interface InterfaceDemo {
//    目标：接口中的成分特点 ：JDK 8之前接口中只能有抽象方法和常量
//    1.常量：
//    注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public static final可以省略不写
    String SCHOOL_NAME = "黑马程序员";
//    public static final String SCHOOL_NAME = "黑马程序员";

//    2.抽象方法
//    注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以省略不写
    void run();
//    public abstract void run();

    void eat();
//    public abstract void eat();
}

在这里插入图片描述

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//        目标：理解接口的基本使用：被类实现
        PingPongMan p=new PingPongMan("张继科");
        p.run();
        p.competition();
        p.rule();
    }
}

Law.java

package Test;

public interface Law {
    void rule();//遵纪守法
}

PingPongMan.java

package Test;

//实现类
public class PingPongMan implements SportMan, Law{
    private String name;

    public PingPongMan(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name+"必须跑步训练");
    }

    @Override
    public void competition() {
        System.out.println(name+"要参加比赛，为国争光");
    }

    @Override
    public void rule(){
        System.out.println(name+"必须守法");
    }
}

SportMan.java

package Test;

//规范
public interface SportMan {
    void run();
    void competition();
}

InterfaceDemo.java

package Test;

//申明了一个接口：体现一种规范，规范一定是公开的
public interface InterfaceDemo {
//    目标：接口中的成分特点：JDK8之前接口中只能有抽象方法和常量
//    1.常量
    //    注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract final可以不写
    String SCHOOL_NAME = "黑马程序员";
//    public static final String SHOOL_NAME = "黑马程序员";

//    2.抽象方法
//    注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以不写
    void run();
//    public abstract void run();
    void eat();
//    public abstract void eat();

}

代码展示

"C:\Program Files\Microsoft\jdk-11.0.12.7-hotspot\bin\jav
张继科必须跑步训练
张继科要参加比赛，为国争光
张继科必须守法

进程已结束,退出代码0

2.接口多继承的使用

在这里插入图片描述

Test.java

package Test;

public class Test {
//    目标：理解接口多继承的作用

}

BasketBallMan.java

package Test;

//一个实现类的：
public class BasketBallMan implements SportMan,Law,People {
    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

SportMan.java

package Test;

//接口可以多继承：一个接口可以同时继承多个接口
public interface SportMan extends Law,People {
    void run();
    void competition();
}

Law.java

package Test;

public interface Law {
    void rule();
}

People.java

package Test;

public interface People {
    void eat();
    void sleep();
}

ACBYCL

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫