AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

黑马全套Java教程（五）（下）

2022-10-29 58
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 黑马全套Java教程（五）

Animal.java


package Demo11;
public class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
}


Cat.java


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


Dog.java


package Demo11;
public class Dog extends Animal{
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }
}


Demo.java


package Demo11;
/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建猫类对象，并测试
        Cat c1 = new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println(c1.getName() + "," + c1.getAge());
        c1.catchMouse();
        Cat c2 = new Cat("橘猫", 6);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();
    }
}


19 包

19.1 包的定义


包的概述


其实就是文件夹


作用：对类进行分类管理


包的定义格式


格式：package 包名;，（多级包用.分开）


范例：package aaa.bbb


带包的Java类编译和执行



记事本演示如下：



编译演示如下


这里需要手动建立Demo01包，然后把生成的class文件放入包中


注意：运行也要带包，要不然会报错




编译演示二：自动建包


这里不需要手动建包，-d运行可以自动建立



19.2 import导包


使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了


为了简化带包的操作，Java就提供了导包的功能


导包的格式


格式：import 包名;


范例：import bao1.bao2.lei1


例如：我要在同一个模块下的Demo2包的Demo.Java中使用Demo1包下的

Teacher.Java，就需要导包


代码如下：




20 修饰符

修饰符的分类


  • 权限修饰符


  • 状态修饰符


20.1 权限修饰符



我们在Demo1中创建三个类：


Fu.Java


package Demo1;
public class Fu {
    private void show1(){
        System.out.println("private");   //只能在本类中被访问
    }
    void show2(){
        System.out.println("默认");
    }
    protected void show3(){
        System.out.println("protected");
    }
    public void show4(){
        System.out.println("public");
    }
    public static void main(String[] args){
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}



Zi.Java


package Demo1;
public class Zi extends Fu{
    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show2();
        z.show3();
        z.show4();
    }
}



Demo.Java


package Demo1;
public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}



之后我们在Demo2中创建两个类：




20.2 状态修饰符


  • final（最终态）


  • static（静态）


1. final


final关键字是最终的意思，可以修饰成员方法、成员变量、类


final修饰的特点：


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


  1. 修饰变量：表明该变量是常量，不能再次被赋值


  1. 修饰类：表明该类是最终类，不能被继承


代码实现：


1.修饰方法：被final修饰的方法叫最终方法，不可被重写



2.修饰变量：被final修饰的变量不能再次修改



3.修饰类：被final修饰的类不可被继承



final修饰局部变量


  • 变量是基本类型：final修饰基本类型的数据值不能发生改变


  • 变量是引用类型：final修饰引用类型的地址值不能发生改变，但是地址里面的内容是可以改变的


package Demo2;
/*
    测试类
 */
public class FinalDemo {
    public static void main(String[] args) {
        //final修饰基本类型变量
        final int age = 20;
        //age = 100;
        System.out.println(age);
        //final修饰引用类型变量
        final Student s = new Student();
        s.age = 100;
        System.out.println(s.age);
        //s = new Student();   //报错
    }
}



2. static


static关键字是静态的意思，可以修饰成员方法、成员变量


特点：


  • 被类的所有对象共享


  • 可以通过类名调用


static.Java


package Demo3;
public class Student {
    public String name;
    public int age;
    //public String university;
    public static String university;   //所有成员共享
    public void show(){
        System.out.println(name + "," + age + "," + university);
    }
}


staticDemo.Java


package Demo3;
public class StaticDemo {
    public static void main(String[] args) {
        Student.university = "南昌";
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        //s1.university = "南昌";   //不建议这样
        s1.show();
        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        //s2.university = "南昌";
        s2.show();
    }
}


静态访问特点



package Demo4;
/*
    static访问特点
 */
public class Student {
    //非静态成员变量
    private String name = "林青霞";
    //静态成员变量
    private static String university = "南昌";
    //非静态成员方法
    public void show1(){}
    //静态成员方法
    public static void show3(){}
    //非静态成员方法
    public void show2(){
        System.out.println(name);
        System.out.println(university);
        show1();
        show3();
    }
    //静态成员方法
    public static void show4(){  //静态成员方法只能访问静态成员变量和静态成员方法
        //System.out.println(name);   //报错
        System.out.println(university);
        //show1();                    //报错
        show3();
    }
}


21 多态

21.1 多态概述


同一个对象，在不同时刻表现出来的不同形态


举例：猫


我们可以说猫是猫：猫 cat = new 猫();


我们也可以说猫是动物：动物 animal = new 猫();


这里猫在不同的时刻表现出来了不同的形态，这就是多态


多态的前提和体现


  • 有继承/实现关系


  • 有方法重写


  • 有父类引用指向子类对象


Animal.java


package Demo1;
public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}


Cat.java


package Demo1;
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


AnimalDemo.java


package Demo1;
/*
    多态：
        同一个对象，在不同时刻表现出来的不同形态
    举例：猫
        我们可以说猫是猫：     猫 cat = new 猫();
        我们也可以说猫是动物：  动物 animal = new 猫();
    多态的前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        a.eat();
    }
}


21.2 多态访问特点


  • 成员变量：编译看左边，执行看左边


  • 成员方法：编译看左边，执行看右边


为什么成员变量和成员方法的访问不一样呢？


  • 因为成员方法有重写，而成员变量没有


Animal.java


package Demo2;
public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}


Cat.java


package Demo2;
public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}


AnimalDemo.java


package Demo2;
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        System.out.println(a.age);  //40，父类中的
        //System.out.println(a.weight);  //报错
        a.eat();  //子类中的
        //a.playGame();   //报错
    }
}


21.3 多态的高处和弊端


多态的好处：提高了程序的扩展性


具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作


多态的弊端：不能使用子类的特有功能


Animal.java


package Demo3;
public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}


Cat.java


package Demo3;
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


Dog.java


package Demo3;
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }
}


Pig.java


package Demo3;
public class Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }
}


AnimalOperator.java


package Demo3;
/*
    动物操作类
 */
public class AnimalOperator {
//    public void useAnimal(Cat c){ //Cat c = new Cat();
//        c.eat();
//    }
//    public void useAnimal(Dog d){
//        d.eat();
//    }
    public void useAnimal(Animal a){
        //相当于
        //Animal a = new Cat();
        //Animal a = new Dog();
        a.eat();
        //a.loolDoor();   //不能访问具体子类所特有的功能
    }
}


AnimalDemo.java


package Demo3;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建动物操作类的对象，调用方法
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);
        System.out.println("--------------");
        Dog d = new Dog();
        ao.useAnimal(d);
        Pig p = new Pig();
        ao.useAnimal(p);
    }
}


21.4 多态中的转型


  • 向上转型：从子到父，父类引用指向子类对象


  • 向下转型：从父到子，父类引用转为子类对象


Animal.java


package Demo4;
public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}


Cat.java


package Demo4;
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}


AnimalDemo.java


package Demo4;
/*
    向上转型
        从子到父
        父类引用指向子类对象
    向下转型
        从父到子
        父类引用转为子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();  //向上转型
        a.eat();
        //a.playGame();   //报错
        System.out.println("-------------------");
        //创建Cat类的对象
//        Cat c = new Cat();
//        c.eat();
//        c.playGame();
//        System.out.println("------------");
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}



案例：猫和狗



Animal.java


package Demo5;
public class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println("动物吃东西");
    }
}


Cat.java


package Demo5;
public class Cat extends Animal{
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


Dog.java


package Demo5;
public class Dog extends Animal{
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}


AnimalDemo.java


package Demo5;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类进行测试
        Animal a = new Cat();
        a.setName("加菲猫");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        a = new Cat("橘猫", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}


本博客到视频d174截止!

文章标签：
Java
关键词：
Java教程
Java黑马
黑马Java教程
zdb呀
目录
相关文章
众所周知
|
2月前
|
Java 开发者 UED
【实战宝典】Java异常处理大师级教程：throws关键字，让异常声明成为你的专属标签！
【实战宝典】Java异常处理大师级教程：throws关键字，让异常声明成为你的专属标签！
众所周知
40 3
java的细水长流
|
14天前
|
Java API
Java时间戳教程
本文详细介绍Java中时间戳的处理方法，包括获取当前时间戳、使用`java.time`包、时间戳与日期的相互转换及格式化等。示例代码展示了如何利用`System.currentTimeMillis()`和`java.time.Instant`获取时间戳，以及如何通过`Date`和`ZonedDateTime`进行日期转换和时区处理。随着Java 8引入的`java.time`包，日期时间操作变得更加强大和便捷，推荐在新项目中优先采用。
java的细水长流
37 8
石小石Orz
|
2月前
|
前端开发 Java Maven
【前端学java】全网最详细的maven安装与IDEA集成教程！
【8月更文挑战第12天】全网最详细的maven安装与IDEA集成教程！
石小石Orz
71 2
【前端学java】全网最详细的maven安装与IDEA集成教程！
龙大吉
|
2月前
|
Java 开发者
Java多线程教程：使用ReentrantLock实现高级锁功能
Java多线程教程：使用ReentrantLock实现高级锁功能
龙大吉
34 1
sunrr
|
2月前
|
存储 网络协议 Oracle
java教程
java教程【8月更文挑战第11天】
sunrr
25 5
bug菌
|
3月前
|
SQL 安全 Java
「滚雪球学Java」教程导航帖（更新2024.07.16）
《滚雪球学Spring Boot》是一个面向初学者的Spring Boot教程，旨在帮助读者快速入门Spring Boot开发。本专通过深入浅出的方式，将Spring Boot开发中的核心概念、基础知识、实战技巧等内容系统地讲解，同时还提供了大量实际的案例，让读者能够快速掌握实用的Spring Boot开发技能。本书的特点在于注重实践，通过实例学习的方式激发读者的学习兴趣和动力，并引导读者逐步掌握Spring Boot开发的实际应用。
bug菌
73 1
「滚雪球学Java」教程导航帖（更新2024.07.16）
最好zzz
|
2月前
|
Java API
Java与Lua互相调用简单教程
【8月更文挑战第29天】在软件开发中，Java以其强大的稳定性和广泛的生态系统著称，而Lua则因其轻量级、灵活和嵌入式的特点在脚本编写、游戏开发等领域大放异彩。将两者结合使用，可以充分利用Java的底层能力和Lua的快速开发优势。本文将通过一个简单的教程，介绍如何在Java程序中嵌入并执行Lua脚本，以及如何在Lua中调用Java方法。
最好zzz
27 0
WXM
|
3月前
|
Oracle Java 关系型数据库
Java JDK下载安装及环境配置超详细图文教程
Java JDK下载安装及环境配置超详细图文教程
WXM
334 3
北京-宏哥
|
3月前
|
测试技术 API Android开发
《手把手教你》系列基础篇（九十七）-java+ selenium自动化测试-框架设计篇-Selenium方法的二次封装和页面基类（详解教程）
【7月更文挑战第15天】这是关于自动化测试框架中Selenium API二次封装的教程总结。教程中介绍了如何设计一个支持不同浏览器测试的页面基类(BasePage)，该基类包含了对Selenium方法的二次封装，如元素的输入、点击、清除等常用操作，以减少重复代码。此外，页面基类还提供了获取页面标题和URL的方法。
北京-宏哥
76 2
程序员大腾
|
3月前
|
Java 数据安全/隐私保护
Java无模版导出Excel 0基础教程
经常写数据导出到EXCEL，没有模板的情况下使用POI技术。以此作为记录，以后方便使用。 2 工具类 样式工具： 处理工具Java接口 水印工具 导出Excel工具类 3 测试代码 与实际复杂业务不同 在此我们只做模拟 Controller Service 4 导出测试 使用Postman进行接口测试，没接触过Postman的小伙伴可以看我这篇博客Postman导出excel文件保存为文件可以看到导出很成功，包括水印 sheet页名称自适应宽度。还有一些高亮……等功能可以直接搜索使用
程序员大腾
68 0
Java无模版导出Excel 0基础教程

热门文章

最新文章

  • 1
    Java获取URL中的顶级域名domain的工具类
  • 2
    阿里Java代码规约插件即将全球首发，邀您来发布仪式现场
  • 3
    《Java 7程序设计入门经典》一1.18　习题
  • 4
    《Spring Boot极简教程》第10章 Springboot集成Kotlin混合Java开发
  • 5
    ZeroMQ(java)之负载均衡
  • 6
    javaweb：判断当前请求是否为移动设备访问
  • 7
    Java中Properties类的操作
  • 8
    JAVA之旅（九）——Object类，equals，toString，getClass，内部类访问规则，静态内部类,内部类原则，匿名内部类
  • 9
    Java工具集介绍11_16
  • 10
    java学习：Hibernate入门
  • 1
    Java 文件处理完全指南：创建、读取、写入和删除文件详细解析
    468
  • 2
    Java的语法基础
    46
  • 3
    Java的面向对象设计
    39
  • 4
    java的类加载过程
    41
  • 5
    java的常见算法
    54
  • 6
    Java的IO技术和NIO技术
    68
  • 7
    JAVA字符串与其他类型数据的转换
    108
  • 8
    JAVA字符串的基本操作
    64
  • 9
    JAVA一维数组
    74
  • 10
    JAVA跳转控制语句
    60

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 1分钟部署经典小游戏
    • 下一篇
    无影云桌面