Day 09Java基础学习笔记

抽象 abstract

抽象类和抽象方法必须用abstract关键字修饰
  • 抽象类格式

    abstract class 类名{}
    
  • 抽象方法定义,在返回值钱,或修饰符前加上abstract关键字
  • 方法没有方法体,即:没有{}
    abstract public void eat();
    public abstract void eat();
    
  • 抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
  • 抽象类完全可以有成员变量和非抽象成员方法

抽象类的子类--使用extends

  • 要么是抽象类,不完全实现其父类的抽象方法
  • 要么重写抽象类中的所有抽象方法,这个子类就是一个完全的实现类了,所以可以用来实例化对象。

抽象类、方法定义时的非法组合

  • private abstract抽象方法依靠子类去实现,但是私有方法在类外就不能访问,也就无法实现
  • final abstractfinal修饰的方法不能被重写,而抽象方法就是需要子类实现,矛盾
  • static abstract抽象方法在本类中是没有方法体的,使用类名调用的时候调用的是没有方法体的方法,无作用

抽象类成员的特点

  1. 成员变量:既可以是变量,也可以是常量
  2. 构造方法:有,用于子类访问抽象类数据的初始化
  3. 成员方法:既可以是抽象的也可是非抽象的
抽象类成员方法的特性
  • 抽象方法 强制要求子类做的事情
  • 非抽象方法 子类继承的事情,提高代码的复用性

抽象类练习

案例:动物-->猫狗

    具体事物:猫,狗
    共性:姓名,年龄,吃
    有共性,所以可以提取出父类,但是由于子类对方法“吃”有不同的实现,所以,将方法“吃”定义为一个抽象方法,所以这个父类也就成了抽象类,这个父类的实现类都需要实现自己的特有的“吃”方法,才是一个可以被实例化的类,否则还是一个抽象类。

    ////定义抽象的动物类
    public abstract class AnimalDemo {
        //私有成员变量
        private String name;
        private int age;
        public abstract void eat(); //抽象方法
        //公有的get/set方法
        public String getName(){
            return name;
        }
        public void setName(String name){
            this.name=name;
        }
        public int getAge(){
            return age;
        }
        public void setAge(int age){
            this.age=age;
        }
        //空参构造方法
        public AnimalDemo(){}
        //有参构造方法
        public AnimalDemo(String name,int age){
            this.age=age;
            this.name=name;
        }
    }
    //继承父类    并实现父类抽象方法
    public  class DogDemo extends AnimalDemo {
        //空参构造方法
        public DogDemo(){}
        //两个参数的构造方法
        public DogDemo(String name,int age){
            //调用父类有参构造方法,并传参
            super(name,age);
        }
        //重写父类抽象方法
        public void eat(){
            System.out.println("Dog eat");
        }

    }
    //继承父类    并实现父类抽象方法
    public class CatDemo extends AnimalDemo {
        public CatDemo(){}
        public CatDemo(String name, int age){
            super(name,age);
        }
        public void eat(){
            System.out.println("cat eat");
        }
    }
    测试类
    public class DemoTest {
        public static void main(String[] args) {
            AnimalDemo ad = new DogDemo("tom",2);//采用多态  父类引用指向子类对象
            ad.eat();
            System.out.println("name:"+ad.getName()+" "+"age:"+ad.getAge());
            AnimalDemo aadd = new CatDemo("jack",3);
            aadd.eat();
            System.out.println("name:"+aadd.getName()+" "+"age:"+aadd.getAge());
        }
    }

接口interface的引入

抽象类是从多个类中抽出来的模板,如果将这种抽象进行的更彻底,则可以提炼出来一种更加特殊的“抽象类”--接口,接口里不能包含普通的方法接口里的所有方法都是抽象方法,其中的成员变量全部是常量。

接口特点

  • 接口用关键字interface表示

    格式:interface 接口名 {} //不能使用class关键字
    类实现结构用 implements关键字
    
  • 格式:class 类名 implements 接口名{}
    接口没有构造方法,即:接口不能实例化
    
  • 按照多态的方式,有具体的子类实例化,其实这也是多态的一种,接口多态

接口的子类

  • 可以是抽象类,用implements关键字
  • 或者还是一个接口 ,用extends关键字
  • 是一个实现类,实现接口中所有抽象方法,用implements关键字

小结

只有接口和接口之间使用的是extends关键字,抽象类和接口之间,实现类和接口之间都是用的implements关键字。

接口成员的特点

  • 成员变量
  • 只能是常量
  • 默认的修饰符public , static ,final ,其中任何一个都可以省略,也可以全省略
  • 构造方法

没有,因为接口主要是扩展功能的,而没有具体存在

  • 成员方法
  • 只能是抽象方法
  • 默认的修饰符 public, abstract,可以省略其一也可以全部省略

类与类,类与接口,接口与接口的关系

  • 普通类与普通类--extends

    继承关系只能单继承,但是可以多层继承

  • 普通类和抽象类--extends

    继承关系,只能单继承,但是可以多层继承

  • 普通类与接口,抽象类与接口--implements

    实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时是想多个接口,此时应该注意extends要写在前,implements写在后

  • 接口与接口--extends

    继承关系,可以单继承,也可以多继承

抽象类和接口的区别

定义时用的关键字

  • 抽象类 abstract
  • 接口 interface

成员区别

  • 抽象类:变量常量都可以有;抽象方法,非抽象方法都可以有;也可以有构造方法
  • 接口:只有常量;只有抽象方法;没有构造方法

关系区别

  • 类与类 :集成,单继承,多层继承
  • 普通类与接口:实现单实现或多实现implements
  • 抽象类和接口:实现,单实现,多实现abstract class a implements IA,IB
  • 普通类和抽象类:继承,并实现全部抽象方法extends
  • 接口与接口:继承 ,单继承,多继承extends
在接口的各种关系中,只有接口与接口是继承关系,其余的和接口之间全部都是实现关系

接口练习

    /*
        猫狗案例,加入跳高的额外功能
        分析:从具体到抽象
            猫:
                姓名,年龄
                吃饭,睡觉
            狗:
                姓名,年龄
                吃饭,睡觉
            由于有共性功能,所以,我们抽取出一个父类:
            动物:
                姓名,年龄
                吃饭();
                睡觉(){}
            猫:继承自动物
            狗:继承自动物
            跳高的额外功能是一个新的扩展功能,所以我们要定义一个接口
            接口:跳高
            部分猫:实现跳高
            部分狗:实现跳高
        实现;
            从抽象到具体
        使用:
            使用具体类
    */
    //定义跳高接口
    public interface Jump {
        public abstract void jump();
    }
    public class Dog extends Animal {
        public void eat(){
            System.out.println("狗啃骨头");
        }
        public Dog(){}
        public Dog(String name,int age){
            super(name,age);
        }

    }

    public class Cat extends Animal {
        public void eat(){
            System.out.println("猫捉老鼠");
        }
        public Cat(){}
        public Cat(String name,int age){
            super(name,age);
        }
    }

    public class JumpDog extends Dog implements Jump{
        public JumpDog(){}
        public JumpDog(String name,int age){
            super(name,age);
        }
        public void jump(){
            System.out.println("狗可以跳");
        }
    }

    public class JumpCat extends Cat implements Jump {
        public JumpCat(){}
        public JumpCat(String name,int age){
            super(name,age);
        }
        public void jump(){
            System.out.println("猫可以跳了");
        }
    }
    //测试类
    public class JumpTest {
        public static void main(String[] args) {
            Animal a =  new Cat("tom",2);
            System.out.println("name:"+a.getName()+" "+"age:"+a.getAge());
            a.eat();
            a.sleep();
            System.out.println("----------------");
            JumpCat jc = new JumpCat("加菲",2);
            System.out.println("name:"+jc.getName()+" "+"age:"+jc.getAge());
            jc.eat();
            jc.jump();
            jc.sleep();
            System.out.println("----------------");
            System.out.println("name:"+a.getName()+" "+"age:"+a.getAge());
            a= new Dog("jerry",2);
            a.eat();
            a.sleep();
            System.out.println("----------------");
            JumpDog jg = new JumpDog("机械狗",2);
            System.out.println("name:"+jg.getName()+" "+"age:"+jg.getAge());
            jg.eat();
            jg.jump();
            jg.sleep();
        }

    }
时间: 2024-10-20 12:57:16

Day 09Java基础学习笔记的相关文章

HTML&CSS基础学习笔记8-预格式文本

<pre>标签的主要作用是预格式化文本.被包围在 pre 标签中的文本通常会保留空格和换行符.而文本也会呈现为等宽字体. <pre>标签的一个常见应用就是用来表示计算机的源代码.当然你也可以在你需要在网页中预显示格式时使用它. 会使你的文本换行的标签(例如<h>.<p>)绝不能包含在 <pre> 所定义的块里.尽管有些浏览器会把段落结束标签解释为简单地换行,但是这种行为在所有浏览器上并不都是一样的. 更多学习内容,就在码芽网http://www.

HTML&CSS基础学习笔记13—无序列表

无序列表 有时我们的工作繁忙,杂事很多,怕忘记,就会把事情一件件列出来,防止忘记. 它们的排列顺序对于我们来说并不重要,可以随意调换,我们将它称为无序列表,HTML里用<ul>标签来表示无序列表,列表里的项目则用<li>标签来表示: 1 2 3 4 5 <ul>     <li></li>     <li></li>     ... </ul> 看一段实例代码: 对于的浏览器显示结果是这样的: 更多内容学习,请

ASP.Net MVC开发基础学习笔记(3):Razor视图引擎、控制器与路由机制学习

首页 头条 文章 频道                         设计频道 Web前端 Python开发 Java技术 Android应用 iOS应用 资源 小组 相亲 频道 首页 头条 文章 小组 相亲 资源 设计 前端 Python Java 安卓 iOS 登录 注册 首页 最新文章 经典回顾 开发 Web前端 Python Android iOS Java C/C++ PHP .NET Ruby Go 设计 UI设计 网页设计 交互设计 用户体验 设计教程 设计职场 极客 IT技术

JAVA基础学习笔记(2)

看了几天的视频了,都没时间来写下学习笔记,今天来写下第二次的学习笔记,前几天看的给忘记了,就写最新看到的吧 主要内容:1.类的变量与函数(方法) 2.对象的存储方式 3.新建一个对象及对象的赋值与调用 4.空对象 5.匿名对象 1.类的变量与函数(方法) class Dog      //类名 { String name;  //变量的声明 int age; String color; void bark()   //方法的定义(返回值为空,不带参数) { System.out.println(

ASP.Net MVC开发基础学习笔记:三、Razor视图引擎、控制器与路由机制学习

一.天降神器“剃须刀” — Razor视图引擎 1.1 千呼万唤始出来的MVC3.0 在MVC3.0版本的时候,微软终于引入了第二种模板引擎:Razor.在这之前,我们一直在使用WebForm时代沿留下来的ASPX引擎或者第三方的NVelocity模板引擎. Razor在减少代码冗余.增强代码可读性和Visual Studio智能感知方面,都有着突出的优势.Razor一经推出就深受广大ASP.Net开发者的喜爱. 1.2 Razor的语法 (1)Razor文件类型:Razor支持两种文件类型,分

JAVA基础学习笔记(1)

今天第一天开始学JAVA,时间:2014年6月17日 学习内容:1.java环境的架设 2.JAVA基本数据类型 1.JAVA环境的架设       1.要先去下载JDK,下载地址 2.安装完成后,设置环境变量 1.1环境变量的设置        1.右键-我的电脑-属性-高级-环境变量-系统变量,找到PATH,在里面加入jdk里bin目录的地址 如:c:\java\bin; 2.新建-名为classpath,值为. 1.2测试JAVA是否配置正确        1.在cmd里面输入javac.

java基础学习笔记day01

java基础学习笔记day01 1.软件开发: 软件:按照特定顺序组织的计算机数据和指令的集合 开发:软件的制作过程 软件开发:借助开发工具和计算机语言制作软件 2.java概述: java之父:詹姆斯·高斯林 JDK:java开发环境 jre:java运行环境 JVM:java虚拟机 java跨平台是因为,JVM能在不同的平台运行,JVM是跨平台的 JavaSE:标准版 JavaME:手机端,物联网 JavaEE:企业版,互联网项目 3.java语言特点: 简单性 解释性 面向对象 高性能 分

linux基础学习笔记——操作大全

作者:liaoyi 更新时间:2014-6-2 ****************基本操作***************** 关机 shutdown -h now    root用户               init 0              root用户halt      root+一般用户poweroff 重启shutdown -r now    root用户init6     root用户reboot            root+一般用户 注意:1.shutdown 比较灵活,可

HTML&CSS基础学习笔记15-合并单元格

合并单元格 之前的文章中,我们已经能够创建一个简单地表格了,如果我们需要把横向的某两个相邻单元格<td>或者纵向的某两个相邻单元格<td>合并,我们该怎么做呢?我们要知道的知识点如下: 1.标签<td>的[colspan]属性规定单元格可横跨的列数,即横向合并的单元格数: 2.标签<td>的[rowspan] 属性规定单元格可横跨的行数,即纵向合并的单元格数: 3.这2个标签也可以同时使用. 样式示例: 现在就来试试合并单元格吧: <!DOCTYPE