Java基础学习 五 复用类(组合、继承、代理、重写、重载、protected关键字、向上/下转型、final关键字、初始化以及类的加载)

最新推荐文章于 2021-07-26 17:29:36 发布
最新推荐文章于 2021-07-26 17:29:36 发布
阅读量188 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39184388/article/details/85144781
版权

图片来自

 

组合语法   (一个类里面使用其他的对象或其他数据类型)

public class Person {
    // 使用其他对象或包装类数据类型作为成员变量称为组合语法 
    private String name,gender = "男";//声明时初始化
    private int age;
    private float height;
    Clothes myClothes = new Clothes();

    public Person(){
        System.out.println("Person()");
        System.out.println("gender"+gender);
        //构造器初始化
        age = 18;
    }
    {
        //实例初始化
        height = 185.4f;
    }
    @Override
    public String toString(){
        //延迟初始化又叫惰性初始化
        if (name == null){
            name = "张三";
        }
        return "name:"+name
                +" gender:"+gender
                +" age:"+age
                +" height:"+height
                +" myClothes"+myClothes;
    }
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}

class Clothes{
    private String s;
    Clothes(){
        System.out.println("Clothes()");
        s = "dress";
    }

    @Override
    public String toString(){
        return s;
    }
}

  继承语法 (利用现有类的类型创建新类  任何一个类都默认继承了object)

class Dog extends Animal {
    public Dog() {
        System.out.println(" Dog()");
    }

    @Override
    public void run() {
        this.append(" Dog run()");
        super.run();
    }
    public void eat(){ this.append(" Dog eat()");}

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
        dog.eat();
        System.out.println(dog);
        System.out.println("---------");
        Animal.main(args);
    }
}

public class Animal {
    private String s = "Animal";

    public Animal() {
        System.out.println(" Animal()");
    }

    public void append(String a){ this.s += a;}
    public void run(){ append(" Animal run()");}

    @Override
    public String toString() {
        return "Animal{" +
                "s='" + s + '\'' +
                '}';
    }

    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.run();
        System.out.println(animal);
    }
}

继承使用 extends 关键字 只能继承一个函数 属于单继承 

创建子类对象时 在调用子类构造器时会先调用父类的无参构造器  如果父类没有无参构造器 则子类的构造器应传入对应类型的值

代理（组合+继承）

public class SpaceShipControls {
    public void up(int velocity){
        System.out.println("SpaceShipControls up"+velocity);
    }
}
public class SpaceShip{
    private String name;
    private SpaceShipControls s = new SpaceShipControls();

    public SpaceShip(String name) {
        this.name = name;
    }
    // 代理 既有继承又有组合
    public void up(int velocity){
        s.up(velocity);
    }
    @Override
    public String toString() {
        return "SpaceShip{" +
                "name='" + name +
                '}';
    }

    public static void main(String[] args) {
        SpaceShip spaceShip = new SpaceShip("NASA");
        spaceShip.up(100);
        System.out.println(spaceShip);
    }
}

组合和继承一起使用  根据需要可以一起使用
 

重写(Override)

方法重写是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型

子类中不能重写父类中的final方法 
子类中必须重写父类中的abstract方法 

public class Animal {
    public void run(){
        System.out.println(" Animal run() ");
    }
}
public class Dog extends Animal {
    @Override
    public void run() { //重写
        System.out.println(" Dog run()");
    }
}

 

重载(Overload)

方法重载是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同

不能根据返回类型区分

public class Dog{
    
    public void run() {
        System.out.println(" Dog run()");
    }
    public void run(int i){
        System.out.println(" Dog run() i:"+i);
    }
    public void run(char c){
        System.out.println(" Dog run() c:"+c);
    }
    public void run(int i,char c){
        System.out.println(" Dog run() i:"+i+" c:"+c);
    }
    public void run(char c,int i){
        System.out.println(" Dog run() c:"+c+" i:"+i);
    }
}

详细解释

protected关键字

public class Dog extends Animal{

    public Dog(String name) {
        super(name);
    }

    public void change(String name){
        changeName(name);
    }

    @Override
    public String toString() {
        return super.toString();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("小黄");
        System.out.println(dog);
        dog.change("旺财");
        System.out.println(dog);
    }
}

class Animal {
    private String name;

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

    protected void changeName(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return name + "run";
    }
}

向上/下转型

public class Dog extends Animal {
    @Override
    public void eat(){
        System.out.println("Dog eat");
    }
    public void run(){
        System.out.println("dog run");
    }
    public static void main(String[] args) {
        //向上转型
        Animal a = new Dog();
        a.eat();
        //a.run();//出错

        //向下转型
        Dog d = (Dog)a;
        d.eat();
        d.run();
    }
}
class Animal {
    public void eat() {
        System.out.println("Animal eat");
    }
}

总结：1. 父类引用可以只想子类对象 而子类引用不能指向父类对象

           2. 子类对象赋给父类引用 为向上转型 不用强制转换

           3. 把指向子类对象的父类引用赋给 子类引用叫向下转型 要强制转换

           4. 如果把父类作为参数 调用时传入子类对象 利用向上转型 使代码变得简介 一个方法能接收所有子类对象 体现了java的抽象编程思想

           5. 如果父类的引用指向的是父类的对象 此时向下转型就会抛出异常

public class Dog extends Animal {
    @Override
    public void eat(){
        System.out.println("Dog eat");
    }
    public void run(){
        System.out.println("dog run");
    }
    public static void main(String[] args) {
        Animal animal = new Animal();

        //编译期不会检测到 如果运行就会出错
        Dog dog = (Dog) animal;
        dog.eat();
    }
}
class Animal {
    public void eat() {
        System.out.println("Animal eat");
    }
}

 Exception in thread "main" java.lang.ClassCastException: mypackage.Animal cannot be cast to mypackage.Dog
    at mypackage.Dog.main(Dog.java:20)

           6.  通过instanceof关键字能判断这个对象是否是这个特定类或者是它的子类的一个实例

public static void main(String[] args) {
        Animal animal = new Animal();

        // 判断这个对象是否是这个特定类或者是它的子类的一个实例
        if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.eat();
        }else {
            animal.eat();
        }

    }

final关键字

  可作用于变量： 

public class FinalData {
    private static Random random = new Random(47);
    private String id;
    public FinalData(String id){
        this.id = id;
    }
    private final int valueOne = 9;  //不可改变
    private static final int VALUE_TWO = 99;  //不可改变
    public static final int VALLUE_THREE = 39; //不可改变
    //实例成员 在同一个对象中不可改变 不同对象的同一个变量不一定一样
    private final int i4 = random.nextInt(20);
    // 静态成员只实例化一次 在不同对象中同一个变量值一样
    private static final int INT_5 = random.nextInt(20);

    private Value v1 = new Value(11);  // v1的引用的对象可以改变
    private final Value v2 = new Value(22); //v2 引用的对象不能改变 但对象中的属性值能改变

    //引用的对象不能改变 但对象中的属性值能改变
    private static final Value VAL_3 = new Value(33);
    private final int[] a = {1,2,3,4,5,6}; // a数组引用不能改变 但数组中的值能改变
    private static final int[] B = {1,2,3,4,5,6}; // B数组引用不能改变 但数组中的值能改变
    @Override
    public String toString(){
        return id+": i4 = " +i4+",INT_5 = "+INT_5;
    }

    public static void main(String[] args) {
        FinalData fd1 = new FinalData("fd1");
//        fd1.valueOne = 3;  final修饰的变量 不能被赋值
        fd1.v2.i = 7;
        fd1.v1 = new Value(9);
        for (int i = 0;i<fd1.a.length;i++){
            fd1.a[i]++;
        }
        System.out.println(fd1.v1.toString());
        System.out.println(Arrays.toString(fd1.a));
        System.out.println(fd1);
        System.out.println("新的数据");
        FinalData fd2 = new FinalData("fd2");
        System.out.println(fd2);
    }

}

class Value{
    int i;
    public Value(int i){
        this.i = i;
    }

    @Override
    public String toString() {
        return "Value{" +
                "i=" + i +
                '}';
    }
}

  空白final：定义成final但是没有初始化复制，可以延申都使用的时候 ，但必须在使用之前对其初始化复制

public class FinalData {
    private final int i = 0;
    private final int j;  //声明空的final时 必须使用构造函数初始化
    private final Value v;//声明空的final时 必须使用构造函数初始化
    public FinalData(int j, Value v) {
        this.j = j;
        this.v = v;
    }
    public FinalData(final int x){  //可以使用final变量修饰参数 修饰的参数不能改变
        this.j = x;
        this.v = new Value(x);
    }
}
class Value{
    int i;
    public Value(int i){
        this.i = i;
    }
}

  可作用于方法：防止所有子类修改 子类不能覆盖    私有的方法 不能被子类覆盖 所以private 和final 共同修饰方法没有意义

public class Main{
    public static void main(String[] args) {
        Value value = new Value();
        value.f();
        value.g();
        FinalData finalData = value;
        //进行强制转换能输出子类的方法 如果不强制转化会报错 因为父类的方法不可见
        ((Value) finalData).f();  
        finalData.g();
    }
}
class FinalData {
    private void f(){ System.out.println("FinalDate f()"); }
    final void g(){ System.out.println("FinalDate g()"); }
}
class Value extends FinalData{
    //于finalData 中的f方法不是继承关系 因为是私有的不能覆盖
    public void f(){  System.out.println("Value f()"); }
    // final 修饰的方法不能被重写
    //public void g(){ System.out.println("Value g()"); }
}

 

          扩展：

             输出结果 ：

            分析： private 修饰的方法属于静态绑定 在编译期 就跟类绑定在了一起 所以调用 的时候是调用的父类的f()方法

                虽然父类的引用 指向的是子类的对象但是父类的f() 方法对子类来说是不可见的 所以子类也不能覆盖 而p引用只能调用子类覆盖的方法 但是子类的f()方法没有覆盖父类的方法所以调用不到子类的f()方法这时候因为启动入口在PrivateOverride中 当程序启动时能直接调用父类的f()方法 如果启动入口不在父类的方法中则会报错

                加上强制转换则会强制转换为子类的对象并调用子类的方法            感觉自己写的好罗嗦啊。。。。

  可作用于   类： 被final修饰的类不能被继承  String类就是final修饰的不能继承

初始化以及类的加载 

public class Beetle extends Insect {
    private int k = printInit("Beetle.k initialized");
    public Beetle(){
        System.out.println("k = " + k);
        System.out.println("j = " + j);
    }
    private static int x2 = printInit("static Beetle.x2 initialized");

    public static void main(String[] args) {
        System.out.println("Beetle constructor");
        Beetle b = new Beetle();
    }
}
class Insect{
    private int i = 9;
    protected int j;
    Insect(){
        System.out.println("i = "+i+",j = "+j);
        j = 39;
    }
    private static int x1 = printInit("static Insect.x1 Initialized");
    static int printInit(String s){
        System.out.println(s);
        return 47;
    }
}

输出结果：

执行顺序： 运行程序 因为静态 main方法 在Beetle类 类加载器会加载Beetle的class文件 检测到Beetle有基类 则会加载基类的class文件 所以

     第一步加载 基类的静态成员变量 

     第二步 加载子类的静态成员变量 

     第三步 加载Beetle的main方法

     第四步 main方法中创建Beetle对象  加载Beetle的 父类 构造方法  

     第五步  加载Beetle 对实例成员初始化

     第六步  加载Beetle的构造方法

 

                  注意： static修饰的变量和方法只初始化一次 在第一次用到这个类的时候静态变量进行初始化  不一定是在new 这个对象的时候初始化。可能是 类.静态方法或成员 这时候也算是用到了这个类 则会把这个类的静态变量进行初始化；如果用到了这个类的静态方法则会初始化用到的静态方法，没有用到的则不会进行初始化。

 

 

 

小马也是行动派
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础入门教程 第4章 继承和多态（共36页）.ppt
12-04
Java中的继承和多态是面向对象编程的重要概念，它们极大地提高了代码的复用性和灵活性。在本章中，我们将深入探讨这两个主题。 首先，我们来理解一下继承的概念。继承允许一个类（子类）从另一个类（父类）中继承...
方法重载实现复用
weixin_44999951的博客
06-17 233
方法重载实现复用
面向对象的复用和重写
ningbufan728903的博客
02-18 341
例题：计算工人，农民，服务生，教师，科学家的年薪，其中工人，农民，服务生只有基本工资，教师还有额外的每天的课酬（元/天），科学家还有年终奖金。 package com.ruicaiedu.work1; public class Jober {     private double salary;     public Jober(double salary) {    
什么是重写？重写的作用？
热门推荐
Thinkingcao的专栏
02-13 6万+
1、什么是重写？ 个人理解：在子类中可以根据需要对从基类中继承来的方法进行重写，重写是对类中方法的扩充，因为继承用的是父类的东西，重写则不仅得到父类的东西，同时也加入了自己的东西 官方理解：在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写...
java复用类之组合语法、继承语法；代理、结合使用组合和继承、组合与继承之间选择；protected关键字、向上转型；final数据-空白final和final参数、final方法、final类；
qq_39268909的博客
10-05 142
组合语法 组合的方法非常直观：只需在新的类中产生现有类的对象。由于新的类是由现有 类的对象所组成，所以这种方法称为组合。该方法只是复用了现有程序代码的功能，而非它 的形式。 数据初始化的四种方式 1.定义的地方初始化 2.在构造器中初始化 3.实例初始化 4.惰性初始化（用的时候初始化，节省内存资源） 继承语法 Detergent的scrub()方法覆盖了父类Cleanser的scrub()方法，要想使用必须用super.scrub()调用基类的方法 父类private
通信中几种复用方式的介绍
weixin_30701521的博客
05-25 3449
通信中几种复用方式的介绍 　　复用是通信技术中的基本概念。在计算机网络中的信道广泛地使用各种复用技术。信道复用技术分为频分复用，时分复用，波分复用，码分复用，空分复用，统计复用，极化波复用。这里主要对频分复用、时分复用和码分复用做介绍。复用的示意图如下图所示： 频分复用 （FDM）Frequency Division Multiplex 用户在分配到一定频带后，在通信过程中自始至终都占有...
学习Java程序入门-面向对象之封装,继承,多态(下).docx
最新发布
06-28
### 学习Java程序入门-面向对象之封装,继承,多态(下) #### 五：再谈继承 继承在面向对象编程中是一项核心概念，它允许创建一个新的类（子类），该类继承了现有类（父类）的属性和行为。通过继承，可以有效地复用...
学习报告(java基础)1
08-08
【Java基础学习报告】 在1~3周的学习中，我们主要深入了Java语言的基础知识，并对JavaScript进行了复习。本文将详细阐述所学习的关键概念。 首先，我们了解了Java语法的基本结构，包括变量、数据类型以及类和对象...
Java 基础核心总结.md
08-11
### Java基础核心总结 #### Java概述 ##### 什么是Java？ Java是一种广泛使用的高级编程语言，由Sun Microsystems（现为Oracle公司的一部分）于1995年发布。它被设计成能够在任何支持Java的设备上运行，这得益...
PHP中类的继承和用法实例分析
10-22
5. `__construct`是构造函数，用于在创建对象时初始化类的属性。子类可以有自己的构造函数，但如果需要调用父类的构造函数，需要使用`parent::__construct()`。 了解这些基本概念后，你可以在实际项目中灵活地应用...
类和对象（构造函数，初始化表达式，对象的销毁，拷贝构造函数，this指针，特殊成员的初始化）
yanglw98的博客
06-06 901
类的定义 类的定义分为两个部分：数据（相当于属性）和对数据的操作（相当于行为）。 类的形式 class 类名 { public: //公有数据成员和成员函数 protected: //保护数据成员和成员函数 private: //私有数据成员和成员函数 }; // 千万不要忘了这个分号 class内部可以拥有的是数据成员(属性)和成员函数(行为)，他们可以分别用三个不同的关键字进行修饰，public、protected、private. 其中public进行修饰的成员表示的是该类可以
C++工程，C++设计模式-组合模式。c++输出运算符重载
m0_37542524的博客
02-19 147
文章目录1,运行效果2,代码示意 c++设计模式 组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得客户端对单个对象和组合对象的使用具有一直性。 既然讲到以树形结构表示“部分-整体”，那可以将组合模式想象成一根大树，将大树分成树枝和树叶两部分，树枝上可以再长树枝，也可以长树叶，树叶上则不能再长出别的东西。 以下情况可以考虑使用组合模式： 希望表示对象的部分-整体层次结构。...
Java 之路 (七) -- 复用类（组合、继承、代理、向上转型、final、再谈初始化和类的加载、方法覆盖）
whdAlive 's blog
08-08 365
学习内容 两种代码复用机制 - 组合 &amp;amp; 继承 以及中庸之道 - 代理 组合 和 继承 如何选择使用 如何结合使用 向上转型 final 关键字 1. 组合 1.1 组合的概念 ​ 在新的类中产生现有类的对象，由于新的类是由现有类的对象所组成，所以这种方法成为组合。 1.1.1 组合的写法及样例 只需要在当前类中声明另一个类的对象作为其成员变量即可，...
Java基础知识 -- 类的复用和多态
KLatitude的博客
07-23 498
一. 类的复用 1. Java语言的一个重要特点：可重用性 从类定义的角度：类的定义封装了类的成员变量和成员方法，类的不同对象实例也就起到了代码复用的效果 从类间关系的角度：关联、依赖、聚合、合成（组合）、继承（纵向关系）、接口实现 依赖：一个类用到另一个类，但这种使用关系是偶然的、临时的。 代码体现：局部变量、方法参数 关联：一个类用到另一个类，但这种使用关系是经常的。 代码体现：成员变量 聚合：整体与局部的关系，是关联的一种，但是整体与部分可以独立存在 合成（组合）：整体与局部的关系，是关联的一
易混淆的概念－－重写、重载、重用、重构
czhxinyu的专栏
03-27 3375
重写：一般在面向对象编程语言中重写指的是方法重写，方法重写又称方法覆盖，就是子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，厕是想作一定的修改，这就需要对方法进行重写。若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数，则新方法将覆盖原有的方法。 重载：在面向对象编程中分为方法重载和运算符重载。方法重载是让类以统一的方式处理不同类型数据
计算机采用什么复用技术,多路复用技术
weixin_30495795的博客
07-26 2485
多路复用技术是把多个低速信道组合成一个高速信道的技术，它可以有效的提高数据链路的利用率，从而使得一条高速的主干链路同时为多条低速的接入链路提供服务，也就是使得网络干线可以同时运载大量的语音和数据传输。多路复用技术是为了充分利用传输媒体，人们研究了在一条物理线路上建立多个通信信道的技术。多路复用技术的实质是，将一个区域的多个用户数据通过发送多路复用器进行汇集，然后将汇集后的数据通过一个物理线路进行传...
4.java面向对象语法学习（部分3-继承，组合，代理）
小鼠标的博客
12-30 6708
java–学习四.java类与对象之复用（继承，组合，代理）1.继承 extends关键字实现 子类可拥有父类所有的字段和方法 一个父类可背多个子类继承（私有的域和方法除外）实例：class A { public A() { System.out.println("A()!"); } } class B exten
复用类（3）：在组合与继承之间选择、protected关键字、向上转型
游王子的博客
01-31 298
一、在组合与继承之间选择 组合和继承都允许在新的类中放置子对象，组合是显式地这样做，而继承则是隐式地做。你或许想知道二者之间的区别何在，以及怎样在二者之间做出选择。 组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情形。即，在新类中嵌入某个对象，让其实现所需要的功能，但新类的用户看到的只是为新类所定义的接口，而非所嵌入对象的接口。为取得此效果，需要在新类中嵌入一个现有...
类，方法，变量（public、protected、private、static、final）
qqqqq1993qqqqq的博客
07-05 3391
[修饰符] class 类名{ 零到多个构造器定义; 零到多个Field; 零到多个方法; }一、类类修饰符： public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。 abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。 final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。 不加修
JavaSE基础：标识符、关键字、数据类型、方法重载等
JavaSE基础包括标识符、关键字、字面量、数据类型、类型转换、修饰符、代码块、方法重载和this关键字等。标识符是为类、方法、变量、常量等定义的名称。在Java语言中，标识符由数字、字母、美元符号和下划线组成，且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小马也是行动派

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值