JavaSE学习笔记（五）

最新推荐文章于 2024-08-12 11:02:49 发布
最新推荐文章于 2024-08-12 11:02:49 发布
阅读量174 收藏
点赞数
文章标签： 多态 interface 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45511599/article/details/108685745
版权

多态：
extends继承 implements实现 是多态的前提
【类与类的继承 接口与接口的继承 类与接口之间的实现】
总之，有上下关系是多态的前提

人（父类）----------学生（子类）、员工（子类）
小明是一个学生（学生形态）也是一个人（人类形态）
小明是一个对象，既有学生形态也有人类形态，一个对象有多个形态，这就是对象的多态性

多态格式：
父类名称 对象名 = new 子类名称（）；
接口名称 对象名 = new 实现类名称（）；

public class Fu {
    public void metod(){
        System.out.println("父类方法");
    }
    public void metod1(){
        System.out.println("父类特有方法");
    }
}

public class Zi extends Fu {
    public void metod(){
        System.out.println("子类方法");
    }
}

public class Demo {
    public static void main(String[] args) {
        Fu obj = new Zi();               //多态
        obj.metod();
        obj.metod1();
    }
}

===============================================
多态访问成员变量
1.直接方法,对于成员变量的访问，看等号左边是谁，就到那个类里去找
2.间接方法，对于成员方法，看属于谁，就先到那个类里找，没有则向上找。

public class Fu {
    int num=10;
    public void NUM(){
        System.out.println(num);
    }
}

public class Zi extends Fu{
    int num=20;
    int ages=200;

}

public class Demo {
    public static void main(String[] args) {
        Fu obj = new Zi();
		
        System.out.println(obj.num);//直接去找

        //System.out.println(obj.ages);    错误，先到Fu类去找，没有则想上找，不会向下（Zi）找

        obj.NUM(); //间接去找
    }
}

====================================================
多态中成员方法的使用方法

  • 成员变量：编译看左边，运行看左边
    成员方法：编译看作左边，运行看右边
 public class Fu {
    public void methodFu(){
        System.out.println("父类方法");
    }

    public void method(){
        System.out.println("fu 10");
    }

}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("子类方法");
    }
    public void method(){
        System.out.println("子 20");
    }
}


public class Demo {
    public static void main(String[] args) {
        Fu obj = new Zi();
        obj.methodFu();  //父类方法//先看左边是Fu，先到Fu类找，有这个方法，再到右边Zi类运行，发现没有，向上找到Fu类，运行此方法

        obj.method();//20// 先看到左边是Fu，先到Fu类去找，有这个方法，再到右边Zi类运行，发现有这个方法，直接运行

        //obj.methodZi(); //看到左边是Fu，先到左边Fu类去找，没有这个方法，就不到右边子类去找了
    }
}

======================================================================================
多态的好处
员工（父类）work（）；//抽象方法
extends或者implements
zilei :讲师 work(jiangke)； 助教 work(fudao);

不是用多态：
Teacher one = new teacher();
one.work();//讲课
Assistant two = new Assistent();
two.work();//辅导

多态：
Employee one = new Teacher();
one.work();
Employee two = new Assistant();
two.work();

好处：无论右边切换成哪个子类对象，等号左边调用方法都不变

对象向上转型
1.对象向上转型就是多态写法
格式： 父类名称 对象名 = new 子类名称（）；
含义：右侧创建一个子类对象，把它当做父类来看待

Animal animal = new cat();

注意：向上转型一定是安全的，从小范围转到了大范围.

================================================
对象向下转型 其实就是一个还原动作
问题：向上转型一定是正确的，但是也有一个弊端
对象一旦向上转型为父类那么无法调用子类原来特有的内容

解决方案：向下转型

格式：子类名称 对象名 = （子类名称）父类对象；
含义：将父类对象，【还原】成本来的子类对象
Animal animal = new Cat();//本来是猫，向上转型成动物
Cat cat = (Cat) animal;//本来是猫，向上转型成动物，还原回来成为本来的猫

注意事项：
1.必须保证对象本来创建的时候，是猫，才能向下转型成猫
2.如果对象创建的时候本来不是猫，现在非要向下转型为猫，就会报错

public abstract class Animal {            //父类定义成为抽象类，用abstract修饰
    public abstract void eat();           //父类中的抽象方法
}

public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void play(){
        System.out.println("猫抓老鼠");//猫特有的
    }
}

public class Gog extends Animal{
    public void eat(){
        System.out.println("狗吃SHIT");
    }
    public void play1(){
        System.out.println("gouzi");
    }
}


public class Demo {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();                    new的是猫类

        //animal.play();
        Cat cat = (Cat)animal;            //强制转
        cat.play();

        //Gog dog = (Gog) animal;         //编译不会报错，运行会报错，转错啦
        //dog.play1();

    }
}

=============================================
用instanceof关键字进行判断

public class Demo {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();

        //animal.play();//错误
		
        Cat cat = (Cat)animal;
        cat.play();

        if(animal instanceof Gog)     //返回一个真假值
        {
            Gog dog = (Gog)animal;
            dog.play1();
        }

        if(animal instanceof Cat)
        {
            Cat catt = (Cat)animal;
            catt.play();
        }

        //Gog dog = (Gog) animal;
        //dog.play1();

    }
}

===============

public class Demo {
    public static void main(String[] args) {
        Animal animal = new Cat();
        
	    giveanimal(new Cat());
	}
	
			
	public static void giveanimal(Animal animal){
	
           if(animal instanceof Gog)     //返回一个真假值
        {
            Gog dog = (Gog)animal;
            dog.play1();
        }

        if(animal instanceof Cat)
        {
            Cat catt = (Cat)animal;
            catt.play();
        }
}
}

=================================================================

Usb
另一篇博客里有详细的讲解
在这里插入图片描述

public interface Usb {                //创建Usb接口
    public abstract  void open();     //构造开机抽象方法
    public abstract void close();     //构造关机抽象方法
}



public class Mouse implements Usb {         //接口实现类
    @Override
    public void open() {                    //实现类引用接口中的抽象方法
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {                  //实现类引用接口中的抽象方法
        System.out.println("关闭鼠标");
    }

    public void play(){                     //Mouse的特有方法
        System.out.println("点击鼠标");
    }
}


public class Key implements Usb{                     //接口的实现类
    @Override
    public void open() {                             //引用接口的抽象方法
        System.out.println("打开键盘");
    }

    @Override
    public void close() {                           //引用接口的抽象方法
        System.out.println("关闭键盘");
    }

    public void play1(){                           //Key实现类的特有方法
        System.out.println("键盘输入");
    }
}


public class Compute {
    public void open(){                     //类里的开机方法
        System.out.println("打开电脑");
    }
    public void close(){                    //类里的关机方法
        System.out.println("关闭电脑");
    }

    public void UseUsb(Usb usb){            //构造一个使用Usb接口的方法，并接收Usb类型的参数
        usb.open();                         //谁new的，看谁实现的接口

        if(usb instanceof Mouse){           //判断实现类是谁，实现对象的向下转型，并调用实现类中的特有方法
            Mouse mouse = (Mouse) usb;
            mouse.play();
        }

        if(usb instanceof Key){
            Key key = (Key) usb;
            key.play1();
        }
        usb.close();
    }
}

public class Demo {
    public static void main(String[] args) {
        Compute compute = new Compute();// new一个Compute对象

        compute.open();                 //电脑开机

        Usb usb = new Key();             //左边是接口，右边是实现类。 这也是多态。

        compute.UseUsb(usb);             //传递Usb类型的参数向compute类里的接收Usb的方法中
        compute.UseUsb(new Mouse());

        compute.close();
    }
}

=================================================================
final关键字
代表最终的、不可改变的
常见四种方法
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.可以用来修饰一个局部变量
4.可以用来修饰一个成员变量

1.当前这个类不能有任何子类（太监类）
public final class 方法名称{
----
}
注意：一个类是final类，那么其中所有成员方法都无法进行覆盖重写

public final class MyClass{
      public void method(){
	       System.out.println("方法执行");
		   }
	}

2.不能被覆盖重写
父类中这个方法被final修饰后，这个方法在子类中不能被覆盖重写

注意：方法来说，abstract关键字和final关键字不能被同时使用

public class Fu {
    public final void meth(){
        System.out.println("final父类");
    }
    public void meth1(){
        System.out.println("无final父类");
    }
}


public class Zi extends Fu {

   /* public void meth(){       //错误写法
        System.out.println("测试");
    }
    */
    public void meth1(){
        System.out.println("覆盖");
    }
}

public class Demo {
    public static void main(String[] args) {
        Zi obj = new Zi();
        obj.meth1();
        obj.meth();
    }
}

==============================================
3.final修饰局部变量

public class Demo {
    public static void main(String[] args) {
        int num1=10;
        num1=20;
        System.out.println(num1);

        final int num2=20;
        /*num2=30;  错误，用final定义后，不能改变值*/

        //正确，只要赋值一次就可以
        final int num3;
        num3=30;

        //对于基本类型来说，不可变的的是变量当中的数据值
        //对于引用类型来说，不可改变的是变量当中的地制值

    Student stu = new Student("赵丽颖");
    System.out.println(stu);//打印的地址，一
         System.out.println(stu.getName());
    stu = new Student("霍建华");
    System.out.println(stu);//打印的地址，与一不同
        System.out.println(stu.getName());


    final Student stu1 = new Student("高圆圆");
    /*stu1=new Student("高圆圆圆圆");  错误，地址不能改变*/

        stu1.setName("高圆圆圆圆");//虽然地址不能改变，但是里面的值可以改变
    System.out.println(stu1.getName());
    }
}



public class Student {
    private  String  name;
    public Student(){

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

    public String getName() {
        return name;
    }

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

==========================================
final修饰成员变量
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，就不会给默认值了
2.对于final成员变量，要么直接赋值，要么通过构造方法进行赋值。二者选其一
3.必须保证类中所有重载的构造方法，都最终会对final的成员变量进行赋值。

愧序深巷
关注
super关键字和this关键字使用时内存的运行过程
wardo_l的博客
02-16 120
照例先上代码： public class Fu { int num = 10; public void method(){ System.out.println("父类成员方法"); } } public class Zi extends Fu{ int num = 20; @Override public void method(){ // 方法名一样，参数列表一样，继承，所以是覆盖重写 super.metho
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
java 19.继承
我是一言
09-22 116
继承 共性抽取 类的继承格式 class 父类 { } class 子类 extends 父类 { } 继承的关系：is-a，父类更通用，子类更具体。 java单继承，java不支持多继承，支持多级继承 继承的特性 子类拥有父类非 private 的属性、方法。 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。 子类可以用自己的方式实现父类的方法。 Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以
JavaSE学习笔记
Aryu的博客
09-02 706
JavaSE（进阶学习）
javase 学习笔记
qq_73240755的博客
08-12 371
public static 返回类型 方法名 （参数...）{}；这里方法名的定义 和变量的要求一样调用 ：如果返回类型为void 则 方法名（参数）；如果是其他类型 则 类型 变量名 = 方法 名（）；
JavaSe学习笔记
MinQo的博客
07-04 2100
JavaSe学习笔记
JavaSE学习笔记第一弹
PleaSure乐事的博客
07-07 1077
JavaSE学习笔记第一弹
JavaSE学习笔记 Day11
CHiN_951的博客
12-05 1013
面向对象三大特征之 多态
JavaSE学习笔记 Day7
CHiN_951的博客
12-04 1052
debug、数组(初始化、遍历、默认值)
JavaSE学习笔记 Day6
CHiN_951的博客
11-30 851
方法
JavaSE学习笔记 Day10
CHiN_951的博客
12-05 937
面向对象三大特征之 封装、继承
javase学习笔记(全)
02-23
这份"javase学习笔记(全)"涵盖了刘意版传智播客课程的主要内容，是学习Java编程语言的重要参考资料。以下将对Java SE的一些关键知识点进行详细解释： 1. **Java基础**：Java的基础语法包括数据类型（如整型、浮点型...
JavaSE:JavaSE学习笔记
04-07
以上只是JavaSE学习笔记的一部分内容，实际的学习过程应结合具体项目实践，通过编写代码加深理解，不断提升编程能力。随着对JavaSE的深入学习，你将能够开发出功能丰富、性能优秀的Java应用程序。
基于C语言的Dao编程语言设计源码
09-28
该项目是一款名为Dao的编程语言设计源码，采用C语言为主要开发语言，并辅以C、C++、Shell和CSS等语言。项目文件共计225个，其中包含126个Dao源文件、39个C源文件、36个C头文件、9个C++源文件、3个文本文件、2个Vim配置文件、1个ChangeLog文件、1个daomake工具文件、1个README文件、1个配置文件。这个项目旨在构建一个高效、可扩展的编程语言环境。
如何自定义数据集进行目标检测_keras-yolo3.zip
09-28
如何自定义数据集进行目标检测_keras-yolo3
基于JavaScript及多语言融合的勤工俭学平台设计源码
09-28
本项目是一款基于JavaScript及多语言融合的勤工俭学平台设计源码，共计367个文件，涵盖231个Java源代码文件、27个XML配置文件、23个JavaScript文件、19个CSS文件、8个PNG图像文件以及少量其他类型文件。该平台旨在为勤工俭学活动提供高效便捷的解决方案，支持多种语言的交互，满足不同用户的需求。
初始化对LoRA微调动态的影响研究
09-28
内容概要：研究了低秩适应（Low Rank Adaptation, LoRA）方法下不同随机初始化设置的效果与动态特性。论文主要发现，在初始化矩阵B为零、矩阵A随机时，模型通常可以使用更大的学习率并取得较好的效果，但这种情况下会出现内部不稳定现象。然而当A被初始化为零而B随机时，则不具备上述优势。通过理论和大量实验证明，初始化选择A而非B将导致更好的优化结果与训练稳定性。 适合人群：机器学习、神经网络的研究员、深度学习领域的科研学者。 使用场景及目标：在大规模语义模型的参数调整过程中选择恰当的初始化配置，从而提升效率以及性能。对于LoRA微调任务来说，在有限算力条件下高效地利用少量新增训练参数进行自适座行动。 其他说明：文中提出的结论有助于未来改进基于小样本学习的任务，同时指出了目前两种初始化方式均存在缺陷，提示可能需要进一步的研究来解决这些问题。尽管当前方法表现优于默认的LoRA初始化，但仍有一定局限性和潜在改进方向。
【PFJSP问题】基于matlab豪猪算法CPO求解置换流水车间调度问题PFSP【含Matlab源码 7895期】.mp4
09-28
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
IGWO-SVM：改良的灰狼优化算法改进支持向量机 采用三种改进思路：两种Logistic和Tent混沌映射和采用DIH策略
最新发布
09-28
IGWO-SVM：改良的灰狼优化算法改进支持向量机。 采用三种改进思路：两种Logistic和Tent混沌映射和采用DIH策略。 采用基于DIH维度学习的狩猎搜索策略为每只狼构建邻域，增强局部和全局搜索能力，收敛速度比GWO更快，适用于paper。
JavaSE学习笔记：核心技术概览
"JavaSE_note 是一份学习Java标准版（JavaSE）的个人笔记，包含了对JavaSE基础知识的记录和理解。" JavaSE（Java Standard Edition）是Java平台的一个核心部分，主要关注桌面应用和客户端开发。以下是JavaSE中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值