day11 包常量抽象类接口

new一个“对象”

已于 2022-05-29 19:21:00 修改

阅读量122

点赞数 1

文章标签： java 开发语言

于 2022-05-29 15:48:25 首次发布

本文链接：https://blog.csdn.net/weixin_52346838/article/details/125030821

版权

本学习内容来着b站：黑马程序员

注：目前遇到了两个问题，其一打字慢，其二学习效率低下，甚至夜晚在床上的时候效率还不错，导致我进度又拉下来了，抓紧时间改正，继续冲。结尾：本内容，当做笔记的复习材料，如果你看到了这篇文章能对你有所帮助，给我点个赞或者评论也是对我更新的最大动力！感谢，内容如果有错误，欢迎各位兄弟姐妹批评指正！！！

一. 包

代码实现：it2 包下的User类

package com.xiaochen.d1_package;

public class User {
    public static int onlineNumber = 121;
}

代码实现：it2 包下的test类

package com.xiaochen.d1_package;
//导包
import com.xiaochen.d1_package.it.Student;
import java.util.Scanner;


public class Test {
    public static void main(String[] args) {
        //目标：理解以下两点
        //1、同一个包下的类，互相可以直接访问
        System.out.println(User.onlineNumber);
        //2、不同包下的类，必须要导包才可以访问
        Student s = new Student();
        Scanner sc = new Scanner(System.in);
        //3、如果这个类中使用不同包下的相同的类名，此时默认只能导入一个类的包，另一个类要使用全名访问
        com.xiaochen.d1_package.it2.Student s2 = new com.xiaochen.d1_package.it2.Student();


    }
}

代码实现： it 包下的student类

package com.xiaochen.d1_package.it;

public class Student {
}

二. 权限修饰符

代码实现：父类

package com.xiaochen.d2_modifier;

public class Fu {
    /*
    1、定义私有的成员：private 只能在本类中访问
     */
    private void privateMethod(){
        System.out.println("----private----");
    }
    /*
    2、定义缺省修饰的成员： 只能在本类中/同包下其他类访问(包访问权限)
     */
    void method(){
        System.out.println("----缺省---");
    }
    /*
    3、protected修饰的方法 本类，同包的其他类中，其他包的子类中
     */
    protected void protectedMethod(){
        System.out.println("---protected--");
    }
    /*
   3、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();
    }
}

代码实现：测试类Test类

package com.xiaochen.d2_modifier;

public class Test {
    public static void main(String[] args) {
        //目标：讲解权限修饰符的修饰范围，明白每一种修饰后的作用
        Fu f = new Fu();
        //f.privateMethod();//报错的，私有的
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

代码实现：idcast 包下的子类

package com.xiaochen.d2_modifier.idcast;

import com.xiaochen.d2_modifier.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.protectedMethod();
        zi.publicMethod();

        Fu fu = new Fu();
        fu.publicMethod();

    }
}

代码实现：idcast 包下的测试类

package com.xiaochen.d2_modifier.idcast;

import com.xiaochen.d2_modifier.Fu;

public class Test2 {
    public static void main(String[] args) {
        Fu f = new Fu();
//        f.privateMethod();//报错
//        f.method();//报错
//        f.protectedMethod();//报错
        f.publicMethod();
    }
}

三. final

代码实现：test

package com.xiaochen.d3_final;

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 final void eat(){
        System.out.println("人都要吃东西");
    }
}
//class Wolf extends Animal{
//}
//final class Animal{
//}

代码实现：test2

package com.xiaochen.d3_final;

public class Test2 {
    /*
    二：修饰静态成员变量(public static final修饰的也称为常量)
     */
    public static final String schoolName = "黑马";
    /*
    三：修饰实例成员变量(几乎不用)
     */
    public final String name = "小庄";

    public static void main(String[] args) {
        //目标：理解final修饰变量的作用，总规则:变量有且仅能被赋值一次(理解语法)
        //变量有几种
        //1、局部变量
        //2、成员变量
        //2.1、静态成员变量
        //2.2、实例成员变量

        //一：修饰局部变量
        final double rate = 3.14;
        //rate = 3.19;//第二次被赋值了
        buy(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 buy(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;
    }
}

四. 常量

package com.xiaochen.d4_constant;
//目标:学会常量的使用，并理解常量
public class ContantDemo1 {
    public static final String SCHOOL_NAME = "小陈集团";
    public static final String USER_NAME = "小陈";
    public static final String PASS_WORD = "123456";
    public static void main(String[] args) {
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);

    }
}

五. 枚举

//枚举类
public enum Season {
    //枚举的第一行必须枚举类的对象名称，建议全部大写
    SPRING,SUMMER,AUTUMN,WINTER;
}

六. 抽象类

6.1 什么是抽象类

代码实现：父类抽象类

package com.xiaochen.d6_abstract;
//抽象类：有abstract修饰
public abstract class Animal {
    private String name;
    //抽象方法：有abstract修饰 不能写方法体代码
    public abstract void run();

    public String getName() {
        return name;
    }

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

代码实现：子类

package com.xiaochen.d6_abstract;

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑得很快");
    }
}

代码实现：测试类

package com.xiaochen.d6_abstract;

public class Test {
    public static void main(String[] args) {
        //目标：先认识抽象类，再了解她的使用场景
        Dog d = new Dog();
        d.run();
    }
}

6.2 抽象的使用场景

6.3 抽象类案例

代码实现：抽象类父类card

package com.xiaochen.d7_abstract_test;

public abstract class Card {
    private String userName;
    private double money;
    //定义一个支付方法，表示卡片可以支付 抽象方法
    public abstract void pay(double money2);

    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

package com.xiaochen.d7_abstract_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 com.xiaochen.d7_abstract_test;

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

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

6.4 抽象类的注意事项

代码实现：

package com.xiaochen.d8_abstract_addition;

public class Test {
    public static void main(String[] args) {
        //目标：理解抽象类的特征和注意事项
        //1、类有的东西，抽象类都有
        //2、抽象类中可以没有抽象方法，但是有抽象方法的必须是抽象类
        //3、一个类继承了抽象类，必须重写抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
        //4、抽象类不能创建对象 为什么？
        //Animal a = new Animal();
        //反证法：假如抽象类可以创建对象
        //a.run();//run方法体都那没有，因此抽象类不能创建对象

    }
}
class Cat extends Animal{
    @Override
    public void run() {

    }
    @Override
    public void eat() {

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

6.5 模板方法

6.6 模板方法案例

代码实现：抽象类父类 student

package com.xiaochen.d9_abstract_template;

public abstract class Student {
    //正式：声明了模板方法
    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

package com.xiaochen.d9_abstract_template;

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

代码实现：子类 studentmiddle

package com.xiaochen.d9_abstract_template;

public class StudentMiddle extends Student {
    @Override
    public String writeMain() {
        return "我的爸爸也很牛，下辈子还要做他的儿子";
    }
}

代码实现：测试类

package com.xiaochen.d9_abstract_template;

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

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

七. 接口

7.1 接口的定义与特点

代码实现：

package com.xiaochen.d10_interface;
//声明了一个接口:体现一种规范，规范一定是公开的
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();
}

7.2 接口的基本使用：被实现

代码实现：接口 sportman

package com.xiaochen.d11_interface_implement;
//规范
public interface SportMan {
    void run();
    void competition();
}

代码实现：接口 law

package com.xiaochen.d11_interface_implement;

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

代码实现：实现类 PingPongMan

package com.xiaochen.d11_interface_implement;

public class PingPongMAN implements SportMan,Law{
    private String name;
    public PingPongMAN(String name){
        this.name = name;
    }
    public void run() {
        System.out.println(name + "必须跑步训练！");
    }

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

    }

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

代码实现：测试类

package com.xiaochen.d11_interface_implement;

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

    }
}

7.3 接口与接口的关系：多继承

代码实现：接口 people

package com.xiaochen.d12_interface_extends;

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

代码实现：接口 low

package com.xiaochen.d12_interface_extends;

public interface Low {
    void rule();
}

代码实现：接口 sportman

package com.xiaochen.d12_interface_extends;
//接口可以多继承：一个接口可以同时继承多个接口
public interface SportMan extends Low,People {
    void run();
    void competition();
}

代码实现：实现类 BasketBallMan

package com.xiaochen.d12_interface_extends;
//一个实现类的：
public class BasketBallMan implements SportMan {
    public void rule() {

    }

    public void eat() {

    }

    public void sleep() {

    }

    public void run() {

    }

    public void competition() {

    }
}

代码实现：测试类

package com.xiaochen.d12_interface_extends;

public class Test {
    public static void main(String[] args) {
        //目标：理解接口多继承的作用。
    }
}

7.4 jdk8 开始接口新增方法

7.4.1 默认方法

7.4.2 静态方法

7.4.3 私有方法

代码实现：

package com.xiaochen.d13_interface_jdk8;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public interface SportManInter {
    //1、jdk8 开始 默认方法(实例方法) 必须default 修饰
    //默认方法：接口不能创建对象，这个方法只能过继给实现类，由实现类的对象调用
    default void run(){
        System.out.println("跑得很快");
    }
    //2、静态方法
    //必须使用static修饰，默认用public修饰
    //接口的静态方法，必须接口名自己调用
    static void inAddr(){
        System.out.println("我们都在学习Java新增的语法，它是Java源码自己会用到的");
    }
    //3、私有方法
    //jdk1.9开始才支持的，必须在接口内部才能被访问
    //private void go(){
       // System.out.println("开始跑");
    //}

    

}
class PingPangMan implements SportManInter{

}
class Test{
    public static void main(String[] args) {
        PingPangMan p = new PingPangMan();
        p.run();


        SportManInter.inAddr();
        //PingPangMan.inAddr();
    }
}

7.4.4 总结

7.5 使用接口的注意事项

代码实现：

package com.xiaochen.d14_interface_attention;

public class Test {
    public static void main(String[] args) {
        //1.接口不能创建对象(接口更加彻底的抽象)
        //2.一个类实现多个接口，多个接口中有同样的静态方法不冲突，
        //3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名的方法，默认用父类的
        Cat c = new Cat();
        c.eat();
        //4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可
        //5、一个接口继承多个接口，是没有问题的，如果多个接口存在规范冲突则不能多继承。
    }
}
//5、一个接口继承多个接口，是没有问题的，如果多个接口存在规范冲突则不能多继承。
interface AAA{
    void run();

}
interface BBB{
    void run();
}

interface CCC extends AAA,BBB{

}


//4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可
interface AA{
    default void go(){
        System.out.println("AA");
    }
}
interface BB{
    default void go(){
        System.out.println("BB");
    }
}
class CC implements AA,BB{

    @Override
    public void go() {

    }
}


//3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名的方法，默认用父类的
interface Food{
    default void eat(){
        System.out.println("接口中的吃方法");
    }
}
class Animal{
    public void eat(){
        System.out.println("父类动物吃");
    }
}
class Cat extends Animal implements Food,A{

}


interface A{
    public static void test(){
        System.out.println("A");
    }
}
interface B{
    public static void test(){
        System.out.println("B");
    }
    //2.一个类实现多个接口，多个接口中有同样的静态方法不冲突，原因是接口的静态方法不能C调用，只能A调A的，只能B调B的
    class C implements A,B{
        public static void main(String[] args) {

        }
    }
}