Java新手学习第五条笔记

已于 2024-09-21 21:22:36 修改
阅读量748 收藏 7
点赞数 10
文章标签： java 学习 笔记
于 2024-09-21 21:13:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pinlei/article/details/142424205
版权

1.关键字final [最终的]
  this
  super
  abstract
  A.修饰变量[存值，传值]：
     基本数据类型变量： final  int A=9; 变量的数值不可以变。
     引用数据类型变量： 变量的内存地址不可以变。
                final  Student stu=new Student();
     【补充：】

  B.修饰方法：
      子类继承后，不可以对final方法进行重写。

  C.修饰类：
       该类是最终类，没有子类，不可以继承该类。

2.接口 非常重要

 为啥需要学习接口？
 ----解决了java是单继承的。
 ----因为接口可以多实现。【接口~抽象父类】

 如何使用接口？
   A.定义一个接口。
     public interface Fly {
         int A=9;
         void fly();
         static void eat(){
             System.out.println("起飞前，先吃饱！");
         }

         default void clear(){
             System.out.println("起飞前，先清扫！");
         }
     }
     B.使用接口：
         实现类 implements  接口名。
    
     补充说明：
       接口中的方法，尽量保持单一性，为了防止”接口污染“！


 接口和抽象父类：
    相同点：
       1.接口不能实例化对象。（没有构造方法）
       2.接口中大部分都是抽象方法。 程序会自动帮忙添加 public abstract 的。
          抽象父类中 也可以有抽象方法。

    不同点：
       1.关键字不同： interface
                    abstract  class
    
       2.接口中没有变量，全都是public static final 修饰的静态常量。
       3.实现接口用到的关键字：implements
         继承父类用到的关键字：extends
         ----继承父类在前，实现接口在后。
       4.接口中，还可以写static ，default修饰的，带有方法体的非抽象方法。
       5.接口可以多实现，  父类只能单继承。

  思考：抽象父类，接口
       功能/能力这个方法？
       继承父类：当前对象 is 父类
       实现接口: 当前对象 has 能力


3.内部类（了解）===当前是为了解决java的单继承问题。

   public  class Demo1{
        static  class Demo2{
        }

        public void show(){
           class Demo3{
    
           }
        }

   }

4.单例模式：
  模式  32 经典设计模式！ ===工厂模式，代理模式，，，
  模式就是一种解决方案。
  单例模式解决的问题是：当前类 只能 有且只有 一个对象。

    1. 构造方法是private ----
       2.本类创建唯一对象
         3.本类提供public方法，为外界访问该对象。

5.多态 ----是为了功能的扩展。  118功能，3 2，3
  多：多个
  态：做事情时候的表现形态。
  多态：在做同一件事情的时候，有多个不同的表现形态。
  多态发生的前提条件：继承，方法重写，【声明父类new子类】 Animal animal=new Dog():

  学习多态的原因？
    动物类:  Dog  Pig  ---父类 Animal类 eat（）

   饲养员类： 喂Dog（）---
              喂Pig();---

   补充：
   多态的效果：在编码期，以父类作参数（这样，该方法适合所有的子类对象，扩展性达到最好）；
              在运行期，会根据实际传入的子类对象，动态调用子类对应的重写方法。
   多态也叫“动态绑定”


 5.1 多态的两个应用场合：

     父类做参数：
    
     父类做返回值类型；

5.2 多态中涉及到的类型转换：

    自动类型转换:小类型转大类型
       Animal animal=new Dog(); ----只能调用继承父类的，或者是重写父类的。


    ===如果想调用子类特有的方法，需要对对象进行强制类型转换。
    强制类型转换：大类型 转小类型
      Dog dog=(Dog)animal;
    
     ===为了防止强制类型转换错误，先判断，在转换。
        if(animal instanceof Dog){
            Dog dog=(Dog)animal;
            dog.leapWall();
        }

下面的也是笔记，比上面的笔记多了一点东西

package com.jr.biji;

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class biji {
    public static void main(String[] args) {

    }

    /*
    一，关键字final  最终的         属于方法修饰符
        1.修饰变量：
            基本数据类型变量：final int A=9；变量的值不可以变
            引用数据类型：变量的内存地址不可以变
           补充：变量{存值，传值}
        2，修饰方法：
            子类继承后，不可以对final方法进行重写
        3.修饰类：
            该类是最终类，没有子类，不可以继承该类
     二，接口
        1，原因：解决java是单继承的，
             因为接口可以多实现  【接口≈抽象父类】
        2，使用：
            1，定义一个接口
                int A=0;

             该方法，用于实现飞的功能
            不需要参数提供，没有返回值
            void fly();
            static void eat(){
               System.out.println("起飞前，先吃");
                }
            default void clear(){
                 System.out.println("起飞前，先清扫");
             }

             2.实现类 implement 接口名
             补充：接口中的方法，要尽可能保持单一性，为了避免“接口污染”
        3.接口和抽象父类
            相同点：
                1.接口不能实例化对象，接口没有构造方法（接口不是类，只有类才有构造方法）
                2.接口中大部分都是抽象方法,也可以有带方法体的静态方法
                    抽象父类中，也可以有抽象方法
            不同点：
                1.关键字不同：
                    interface
                    abstract class
                2.接口中没有变量，只有public static final 修饰的静态常量
                3.实现接口用到的关键字是implement
                    继承父类用到的关键字是extends
                        继承父类在前，接口在后，多个接口要用,隔开
                4.接口中，除了抽象方法外，还可以写 static，default修饰的带有方法体的非抽象方法
                5.接口可以多实现，父类只能单继承

          功能/能力这个方法：
            继承父类：
            接口：
     三，内部类（了解）---->当时是为了解决java的单继承问题
        一个类里面套另一个类
        public class Demo1{
            public class Demo2{
            demo2是demo1的内部类
            }
        }
     四，单例模式：
        模式：就是一种解决方案
            32 经典设计模式！---较重要（单例模式，工厂模式，代理模式）
            单例模式解决的问题是：当前类只能有且只有一个对象
                1.单例模式构造方法是private
                2.该单例对象必须由单例类自行创建；
                3.单例类对外提供一个访问该单例的全局访问点。简单说就是单例类中有一个静态方法可以获取单例对象。

    五，多态----->功能的扩展         多态只能调用重写方法
        什么是多态：同一个父类下，不同的子类再做同一行为的时候，有不同的表现形式就是多态
        多：多个
        态:做事情时候的表现形态
        多态：在做同一件事情的时候，有多个不同的表现形态
        多态发生的前提条件：
            继承父类/实现接口，方法重写之后还要有{声明父类new子类}Animal animal=new Dog();
                                                 声明 父类 new 子类
        学习多态的原因（多态的作用）：
            ----极大的提高了代码的扩展性

        补充：
            多态的效果，在编码期，以父类做参数（这样，该方法适合所有的子类对象，扩展性达到最好）
                       在运行期，会根据实际传入的子类对象，动态调用子类对应的重写方法
            多态也叫“动态绑定”
        1.多态的两个应用场合（两种表现形式）：
            父类做参数：---代码的扩展性达到极致
            父类做返回值类型：---提高了代码的扩展性，但是没有达到极致
                   ---反射可以解决父类做返回值时，扩展性没有达到极致的问题
        2.多态的使用场合：
            有两条业务线，其中一条是继承业务线
                        在第二条业务线中，一种一个方法，是继承线的父类在做参数或者做返回值
                        方法体中，传入的实际参数调用重写的方法
        3.Java中所有的数据类型都会涉及到类型转换
            java中数据类型分为两种；基本数据类型：整数：byte 一个字节 short 2个 int4个 long8个
                                              浮点：float4个 double8个
                                              字符：char2个
                                              布尔：boolear 1位
                    补充：1.Java中boolear 不参与基本数据类型的类型转换
                         2.byte short char 三者之间不进行类型转换，他们三个都是最小类型
                         3.基本数据类型，从小到大排列：
                            （byte shory char）<int<long<float<double
                         4.从小类型转大类型是自动类型转换
                         5.大类型转小类型是强制类型转换
                                小类型  名=（小类型名）大类型
                                        int b=(int)double;
                                 引用数据类型：
                         1.不是所有的引用类型变量，都可以做数据转换
                         引用数据类型转换，只有两种：向上类型转换，向下类型转换
                            1.向上类型转换发生在多态，声明父类 new 子类
                            ----声明父类 new 子类 生成的对象有弊端，不能调用子类特有的行为/能力（方法）
                            2.向下类型转换：
                                Dog dog=(Dog)animal;  dog可以调用子类特有的方法  dog在之前已经向上转换为父类类型
                                ---隐患：可能会存在向下类型转换错误
                                ---解决：instanceof
                                     if(对象 instanceof 类型){//判断对象是该类型下的吗
                                     }

        4.多态中涉及到的类型转换：
            1.自动类型转换：小类型转大类型       向上转型
                Animal animal=new Dog()；---->animal只能调用继承父类的，或者是重写父类的方法
            如果想要调用子类特有的方法，需要对对象进行强制类型转换
            2.强制类型转换：大类型转小类型        向下转型
                Dog dog=(Dog)animal；
             为了防止强制类型转换错误，需要先判断，再转换 instanceof 判断该对象是否是这个类下的
             if(animal instanceof Dog){
                Dog dog=(Dog)animal;
                dog.leapWall();
             }
        六，简单工厂设计模式：
            要求：
            1，定义一个static方法，通过类名直接调用
            2，返回值类型是父类类型，返回的可以是其任意子类类型
            3，传入一个字符串类型的参数，工厂根据参数创建对应的子类产品
            解决的问题：
                解决大量对象创建问题的一个解决方案
        七常用类：
            1，[Object类]
                 所有类都直接或间接的继承自Object类，Object类是所有Java类的根基类。
                 也就意味着所有的Java对象都拥有Object类的属性和方法。
               隐式:---Object
                显示:extends 类名

            包：在java.long下，【该包很特殊，程序会自动帮忙导入该包下的所有类】
            构造器：无参构造，Object();
            属性：无
            方法：
                1，toString();---将当前内存对象，转成字符串形式，返回给调用者
                    return getClass().getName() + "@" + Integer.toHexString(hashCode());
                          com.jr.date725.Student   @        140e19d
                    --重写对象时，更希望获得该对象的所有属性信息，而不是内存地址，所以需要重写toString方法
                    equalst();====在Object类中，原本是比较地址的，开发者希望该方法用于属性值，所以要进行重写。
                    public boolean equals(Object obj) {
                        return (this == obj);
                    }

                    hashCode();====  equalst()如果确定两个对象是相等的话，那么两个对象的hash值也应该相同，
                       所以hashCode方法也进行重写。
                    public int hashCode() {
                        //return Objects.hash(stuid, stuname, phone);
                        return stuid+stuname.hashCode()+phone.hashCode();
                     }
                【重点：HashSet 集合 ----去重功能：
                         去重原理：首先比较两个对象的hash值是否相等，
                         如果hash值不等，可以存储；
                         如果hash值相等，在使用equalst()方法比较两个对象的属性是否都相等，
                               如果属性都相等，不可以存储
                               如果属性不相等，可以存储。

             2，【包装类】
                八个基本数据类型，分别有对应的包装类

                原因：1，基本数据类型不具备面向对象思想（希望用 对象.方法()来解决问题）
                     2，集合≈数组  集合只能存储引用数据类型变量
                int----Integer;
                自动拆装箱： 基本数据--->包装类型==装箱
                 int a=9;
                 Integer i=new Integer(9);这个过程为包箱

                 拆箱：包装类型---->基本数据
                              XXXXValue();

                String---基本类型之间的转换：
                    int c=Integer.parseInt("123");

                    基本类型----String类型转换：
                    Integer i1=new Integer(d);
                    System.out.println(i1.toString()+4);
                    System.out.println(d+"");

             3，【字符串处理类】
                java中准备的字符串处理类一共有三类：
                    String：不可变的字符串      是final修饰的    final char[]
                        一个内存地址只对应一个值---不可变      final修饰一个引用数据类型时，表示的是内存地址不可变，但值可变
                    StringBuffer：可变的字符串，线程安全的字符串，但效率低
                    StringBuilder：可变的字符串，线程不安全的字符串，但效率高
                        【可变】指一个内存地址可以对应多个值

                【String类】
                    1，在哪个包下  java.long
                    2，继承结构，实现结构
                    3，构造方法有哪些
                    4，常用的属性有哪些
                    5，常用的方法有哪些，并且怎么用
                            All Implemented Interfaces: 已实现的接口:
                            Serializable ， CharSequence ， Comparable < String >

                            public final class String
                            extends Object
                            implements Serializable, Comparable<String>, CharSequence

                concat(String str)  拼接
                contains(CharSequence s) 判断元素是否存在。
                indexOf(int ch)  根据元素找下标
                lastIndexOf
                length(); 获得字符串长度的方法。
                    String A="1234";
                    String B="5678";
                    System.out.println(A.compareTo(B));//比较A和B的大小
                    System.out.println(A.charAt(1));//根据下标返回元素
                    String C=A.concat("56");//拼接
                    System.out.println(A.length());//返回字符串的长度
                    System.out.println(C.length());
                    System.out.println(A.contains("3"));//判断元素是否存在
                    System.out.println(A.indexOf(2));//根据元素返回下标
                    System.out.println();
                    //lastIndexOf(String str, int fromIndex)
                    //返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。

                    //split(String regex)
                    //将此字符串分割为给定的 regular expression的匹配。
                    String [] split=A.split("2");//从2拆分，返回前后两个字符串
                    System.out.println(Arrays.toString(split));

                    //substring(int beginIndex)         截取字符串中的一段
                    //返回一个字符串，该字符串是此字符串的子字符串。
                    String id="210381";
                    System.out.println(id.substring(2,4));//前面包含，后面不包含
                    System.out.println(id.substring(2));//从2开始往后全截

             【StringBuffer类】----不管内容怎么改变，地址始终都不变。
                    StringBuffer stringBuffer=new StringBuffer("asdfg");
                    StringBuffer stringBuffer1=stringBuffer.append("000");
                    System.out.println(stringBuffer.length());
                    System.out.println(stringBuffer==stringBuffer1);
                    stringBuffer.replace(0,3,"666");
                    System.out.println(stringBuffer);

      [时间日期类]
        1.第一阶段：时间日期类
            java.util.Date
            Date dt=new Date();
        //当前系统时间, 西方国家的默认格式。
        dt： 2024 -年
             CST --时区
             15:44:58  时 分 秒
             25 ---日
             Jul---月
             Thu---星期
                1，java.util.Date  有无参构造
                Date dt=new Date();//当前系统时间，西方国家的默认格式
                System.out.println(dt);
                System.out.println("年:"+dt.getYear());//弃用，不推荐使用，但也能用       从1900年开始算
                System.out.println("月:"+dt.getMonth());//实际月份等于输出月份加一
                System.out.println("日:"+dt.getDate());
                System.out.println("时:"+dt.getHours());
                System.out.println("分:"+dt.getMinutes());
                System.out.println("秒："+dt.getSeconds());
                System.out.println("星期："+dt.getDay());
                dt.setYear(124);
                dt.setMonth(8);
                dt.setDate(1);
                System.out.println(dt);
                dt=new Date(dt.getTime());
                System.out.println(dt);

                2，java.sql.Date
                java.util.Date 与 java.sql.Date 区别：
                        1.java.sql.Date 没有无参构造
                        2.java.util.Date 可以存储和获得 年月日，时分秒
                            java.sql.Date 只能存储和获得 年月日。
                        3.java.sql.Date 是子类
                            java.util.Date 是父类

                3，DateFormat 时间的格式化类
                    Date dt=new Date();
                    System.out.println(dt);
                    //希望年月日之间是/，时分秒之间是：
                    DateFormat df=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//DateFormat抽象类，不能new自己，所以new它的子类SimpleDateFormat
                    System.out.println(df.format(dt));
         2，第二阶段时间：
            第一阶段中时间类型的方法已经弃用了
            jdk推荐使用Calendar类，进行时间管理
            Calendar日历类
                 public static void test5(){
                        //1.接收
                        System.out.println("请输入一个时间（年-月-日）");
                        String str=new Scanner(System.in).next();
                        //2.转换：String---calender
                        java.sql.Date dt=java.sql.Date.valueOf(str);
                        Calendar calendar=Calendar.getInstance();//calendar 是当前系统时间。
                        calendar.setTime(dt);//calendar 代表 用户输入的时间。

                        //3.1  获得输入月份有多少天？
                        int days=calendar.getActualMaximum(Calendar.DATE);//获得该月份的最大日期。
                        //3.2  获得输入月份的1号是星期几？
                        calendar.set(Calendar.DATE,1);
                        int num=calendar.get(Calendar.DAY_OF_WEEK); //获得的是，本周当中的第几天，而不是星期几。

                        //4.输入日历：
                        System.out.println("日\t一\t二\t三\t四\t五\t六\t");
                        for(int i=1;i<=num-1;i++){
                            System.out.print("\t");
                        }
                        for (int i=1;i<=days;i++){
                            System.out.print(i+"\t");
                            calendar.set(Calendar.DATE,i);
                            if(calendar.get(Calendar.DAY_OF_WEEK)==7){
                                System.out.println();
                            }
                        }
                 }

     【异常处理机制】：处理程序向外报错的
        作用：---保证程序不会因为一点小问题就终止，而是还可以正常运行下去

        保证程序不终止的两种解决方案：
            第一种：这个问题，我能解决
                tyr{ 监控异常

                }catch{ 捕获异常

                }finally{ 善后异常

                }
                try中代码没有问题，不执行catch块，执行finally
                try中代码有问题，执行类型匹配的catch块，执行finally
                     没有找到类型匹配的catch块，执行finally,程序再终止
            第二种：这个问题，我解决不了
                声明异常：throws 异常类型
                public static void meno2() throws ArrayIndexOutOfBoundsException{
                    System.out.println("程序第1行");
                    System.out.println("程序第2行");
                    System.out.println("程序第3行");

                    int[] as=new int[10];
                    System.out.println(as[10]);

                    int a=0;
                    System.out.println(9/a);

                    System.out.println("程序第4行");
                    System.out.println("程序第5行");
                    System.out.println("程序第6行");
                }

           异常处理机制中有五个关键字；try,catch,finally,throws,throw
            throw:自己制造一场异常？
            原因：提醒调用者重视这个问题，throw new NullPointerException("年龄的合适范围是0-100");

            自定义异常类型：
            public class AgeException extends Exception {

                public AgeException(String info){
                    super(info);
                }
            }

     */
}

多态练习：

例一：

        里面包含了动物类，和测试类，注意下面代码不要放在同一个类中

//Animal类
package com.jr.date724.duotai.dongwuyuan;

public abstract class Animal {

    public abstract void eat();

}


//Bird类
package com.jr.date724.duotai.dongwuyuan;

public class Bird extends Animal {
    @Override
    public void eat() {
        System.out.println("小鸟吃谷子");
    }
}


//Breeder类
package com.jr.date724.duotai.dongwuyuan;

public class Breeder {
/*
    public void feed(Dog dog){
        dog.eat();
    }

    public void feed(Pig pig){
        pig.eat();
    }
 */
    public void feed(Animal animal){
        animal.eat();
        if(animal instanceof Dog){
            Dog dog=(Dog)animal;
            dog.leapWall();
        }
    }
}


//Dog类
package com.jr.date724.duotai.dongwuyuan;

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }

    public void leapWall(){
        System.out.println("急了");
    }

}


//pig类
package com.jr.date724.duotai.dongwuyuan;

public class Pig extends Animal {

    @Override
    public void eat() {
        System.out.println("小猪吃蔬菜");
    }

    public void jump(){
        System.out.println("上树");
    }

}


//Test类
package com.jr.date724.duotai.dongwuyuan;

public class Test {
    public static void main(String[] args) {
        Breeder breeder=new Breeder();
        Pig pig=new Pig();
        breeder.feed(pig);

        breeder.feed(new Dog());

        Bird bird=new Bird();
        breeder.feed(bird);

        Animal animal=new Dog();//向上类型转换，自动类型转换，小类型转大类型会发生自动类型转换  不能调用子类特有的方法
        Dog dog2=(Dog) animal;//向下类型转换，强制类型转换

    }
}

例二：

披萨制作

//工厂类
package com.jr.date724.duotai.pisaizhizao;

import java.util.Scanner;

public class GongChang{

    public GongChang() {
    }

    public PiSa work(){
        Scanner input = new Scanner(System.in);
        System.out.println("请选择想要制作的披萨:(1.培根披萨，2海鲜披萨)");
        int i = input.nextInt();
        PiSa piSa=null;
        if(i==1) {
            System.out.println("请输入培根克数：");
            double keShu = input.nextDouble();
            System.out.println("请输入披萨大小：");
            int size = input.nextInt();
            System.out.println("请输入披萨价格：");
            double jiage = input.nextDouble();
            piSa = new PeiGen("培根披萨", jiage, size,keShu);
        }else{
            System.out.println("请输入配料信息：");
            String peiLiao = input.next();
            System.out.println("请输入披萨大小：");
            int size = input.nextInt();
            System.out.println("请输入披萨价格：");
            double jiage = input.nextDouble();
            piSa = new HaiXian("海鲜披萨", jiage, size,peiLiao);
        }
        return piSa;
    }
}


//海鲜配料类
package com.jr.date724.duotai.pisaizhizao;

public class HaiXian extends PiSa{
    private String peiliao;

    public HaiXian(String name, double jiage, int size, String peiliao) {
        super(name, jiage, size);
        this.peiliao = peiliao;
    }

    public HaiXian(String peiliao) {
        this.peiliao = peiliao;
    }

    public HaiXian(String name, double jiage, int size) {
        super(name, jiage, size);
    }

    public HaiXian() {
    }

    @Override
    public void show() {
        System.out.println("名称："+getName());
        System.out.println("价格："+getJiage());
        System.out.println("大小："+getSize());
        System.out.println("配料："+peiliao);
        System.out.println("披萨工厂制造了一个海鲜披萨！");
    }
}


//培根配料
package com.jr.date724.duotai.pisaizhizao;

public class PeiGen extends PiSa{
    private double keshu;

    public PeiGen(String name, double jiage, int size) {
        super(name, jiage, size);
    }

    public PeiGen() {
    }

    public PeiGen(String name, double jiage, int size, double keshu) {
        super(name, jiage, size);
        this.keshu = keshu;
    }

    public PeiGen(double keshu) {
        this.keshu = keshu;
    }

    @Override
    public void show() {
        System.out.println("名称"+getName());
        System.out.println("价格："+getJiage());
        System.out.println("大小："+getSize());
        System.out.println("培根克数："+keshu);
    }
}


//披萨类
package com.jr.date724.duotai.pisaizhizao;

public abstract class PiSa {
    private String name;
    private double jiage;
    private int  size;

    public PiSa(String name, double jiage, int size) {
        this.name = name;
        this.jiage = jiage;
        this.size = size;
    }

    public PiSa() {
    }

    public String getName() {
        return name;
    }

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

    public double getJiage() {
        return jiage;
    }

    public void setJiage(double jiage) {
        this.jiage = jiage;
    }

    public int  getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public abstract void show();
}


//Test类
package com.jr.date724.duotai.pisaizhizao;

public class Test {
    public static void main(String[] args) {
        GongChang gongChang=new GongChang();
        PiSa piSa=gongChang.work();
        piSa.show();
    }
}

接口例题

例一：

//Bird类
package com.jr.date724.jiekou1;

public class Bird implements Fly{

    @Override
    public void fly() {
        System.out.println("通过体能转换为动能，扇动翅膀，飞起来！");
    }

}


//注意下面这个是一个接口
package com.jr.date724.jiekou1;

public interface Fly {
    int A=0;

    /*
    该方法，用于实现飞的功能
    不需要参数提供，没有返回值
     */
    void fly();

    static void eat(){
        System.out.println("起飞前，先吃");
    }
    default void clear(){
        System.out.println("起飞前，先清扫");
    }
}


//Test类
package com.jr.date724.jiekou1;

public class Test{
    public static void main(String[] args) {

    }
    
}

例二：

//动物类
package com.jr.date724.jiekou2;

public abstract class DongWu {
    private String name;
    private String color;
    private String leibie;

    public DongWu(String color, String name, String leibie) {
        this.name = name;
        this.color = color;
        this.leibie = leibie;
    }

    public DongWu() {
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getLeibie() {
        return leibie;
    }

    public void setLeibie(String leibie) {
        this.leibie = leibie;
    }
    public abstract void eat();

    public abstract void jiao();

}


//青蛙
package com.jr.date724.jiekou2;

public class QingWa extends DongWu implements YouYong {

    public QingWa(String color, String name, String leibie) {
        super(color, name, leibie);
    }

    public QingWa() {
    }

    @Override
    public void eat() {
        System.out.println("青蛙是"+getLeibie()+",爱吃昆虫");
    }

    @Override
    public void jiao() {
        System.out.println("那只"+getColor()+"的，名叫"+getName()+"的青蛙正在呱呱的叫");
    }

    @Override
    public void youyong() {
        System.out.println("虽然不是鱼，但"+getName()+"也是游泳高手");
    }
}


//兔子
package com.jr.date724.jiekou2;

public class TuZi extends DongWu{

    public TuZi(String color, String name, String leibie) {
        super(color, name, leibie);
    }

    public TuZi() {
    }

    @Override
    public void eat() {
        System.out.println("兔子是"+getLeibie()+",爱吃胡萝卜");
    }

    @Override
    public void jiao() {
        System.out.println("那只"+getColor()+"的，名字叫"+getName()+"的兔子"+"正在叽叽的叫");
    }
}


//注意，下面是一个接口
package com.jr.date724.jiekou2;

public interface YouYong {
    void youyong();
}


//Test类
package com.jr.date724.jiekou2;

public class Test {
    public static void main(String[] args) {
        TuZi tuZi=new TuZi("黑色","美人","哺乳类");
        tuZi.jiao();
        tuZi.eat();
        System.out.println("****************************************************");
        QingWa qingWa=new QingWa("绿色","大兵","非哺乳类");
        qingWa.jiao();
        qingWa.eat();
        qingWa.youyong();
    }
}

微ws
关注
Java学习笔记
stange1的博客
05-06 5373
1.2.1 首先找到此电脑，右键点击属性，可以按照下面的界面；点击【高级系统设置】，再点击【环境变量】 1.2.2 找到JDK的bin目录，复制一下 1.2.3 将JDK的bin目录粘贴在Path环境变量后面 1.2.4.在CMD输入javac -version 看提示信息是否显示你安装JDK的版本号​ 1、java 基础（Java SE）标准版 2、就业方向：①JavaEE软件工程师②大数据③android开发 3、运行原理示意图 4、Java 开发注意事项和细节说明 5、如何快速掌握技术或知识点 代
1、【狂神说Java】Java零基础学习笔记-Java基础
cuter_的博客
07-26 1118
【狂神说Java】Java零基础学习笔记-Java基础
狂神说java java基础篇 学习笔记
weixin_45975667的博客
03-29 1880
狂神说java java基础篇学习笔记，包括了狂神基础视频的所有内容
【我的Java学习笔记-1】
yhbbbbbb的博客
03-09 2115
本文用以记录个人学习Java的路程，同时发布一些平时遇到的在Java学习上遇到的问题，及提供相应的解决方案（多数情况下是搬运和整合），我本人用的书是《Java面向对象程序设计（第三版）》微课视频版&《Java核心技术 卷Ⅰ》（基础知识），这两本书我会交替看着学，相互补充；但书是死的，人是活的（其实人也可以是🤦‍♂️）我会在这两本书之外，上网整合一些书本中未提及的知识（可能会有吧）另外会有一些个人的思想/思路在里面，注意甄别好坏哦。接下来开始踏上学习Java的道路吧。冲冲冲！
Java 多线程 学习 笔记 （超详细，适合新手反复观看）
IT小小白的博客
08-28 435
Java 多线程 学习 笔记 超详细，适合新手反复观看
新手学java 笔记
m0_74124657的博客
12-28 801
1.为什么要配置环境变量：配置环境变量是为了能在运行-cmd-中用java命令来编译和运行java代码，在我们的window系统中安装的软件都是要有特定的路径的，所有软件的运行或使用都是从特定的路径中来启动的，就如同这些软件一样，如果不配置环境变量的话，就只能在jdk的安装路径下才能运行，如果换到了其他路径就不能使用了，系统就会提示找不到路径，如果想要在任何情况下都能使用和运行jdk，那么就要去配置环境变量。而java更贴近人的思维，让电脑去理解人的，去执行人的要求的一门语言。面向对象，之后会学）
狂神说Java--Java学习笔记(合集)
Ajekseg的博客
04-12 1037
笔记参考来源狂神说Java视频https://www.bilibili.com/video/BV12J41137hu 本篇笔记有点长，可以根据目录定位，建议配合视频学习。 预科 什么是计算机 名称：Computer，全称电子计算机，俗称电脑。 定义：能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。 组成：由硬件和软件组成。 形式：常见显示有台式计算机、笔记本计算机、大型计算机等。 应用：科学计算、数据处理、自动控制、计算机辅助设计、人工智能、网络等领域。 硬件及冯诺依曼结构 计算机硬件 组
Java新手村《瑞吉外卖》笔记
apple_52917586的博客
03-22 974
瑞吉外卖笔记
学习java基础第一天笔记
qq_52854229的博客
03-14 1889
dos命令符教程 打开 cmd 方式 1.开始+系统+命令提示符 win键+R 在任意文件夹下桉住shift 常用DOS命令 #盘符切换 直接打DE #查看当前目录下的文件 dir #切换目录 cd (change directory) cd /d f cd..返回上一级目录 #清理屏幕 cls (clear screen) #退出终端 exit #查看电脑IP ipconfig #ping命令 ping www.baidu.com 编写java程
java学习笔记——入门篇（长期更新）
weixin_43563431的博客
09-05 580
java学习笔记 Ps.博主大二学生，这学期开始学习java，下面内容全是自己理解和一些想法，如果有什么出入，请大家指出。 选用的教材：清华大学出版社的《java程序设计基础（第六版）》和《Java从入门到精通》，中国农业出版社的《java程序设计》，中国电力出版社的《Head First Java》。 java语言的概述 ①什么是java虚拟机？ A：java虚拟机即JVM（java virtu...
java学习笔记_笔记.txt
07-02
java 2实用教程第五版，内容适合新手入门，讲解通俗易懂，让我们一起学习java吧，let's go!
Java学习速成笔记
03-23
### Java学习速成笔记 #### 一、概览与学习目标 本篇“Java学习速成笔记”旨在帮助读者在短期内快速掌握Java编程的核心概念和技术要点，并能够在学习后的七天内具备基本的工作能力。该笔记内容详实，既适合零基础...
Python与Java对比学习笔记.pdf
10-04
而Java的学习曲线可能更陡峭，但对于长期的软件开发职业生涯，掌握Java也是十分必要的，因为它的广泛应用和强大的生态系统。 无论选择Python还是Java，都有各自的优点和适用场景。重要的是理解每种语言的核心概念，...
Android学习新手笔记
03-24
整个笔记强调了在Android学习过程中，Java编程知识的重要性，并提供了大量代码实例来帮助新手理解Android开发的核心概念和常用组件的使用方法。这份笔记可以作为学习Android开发的入门教材，它覆盖了从基础到实战...
工厂模式的介绍及实现
户伟伟的博客
09-25 72
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 492
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 203
BI商业智能：数据可视化、报表可视化系统。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 693
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
最新发布
y050505的博客
09-25 411
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值