读书笔记-think in java

Think In JAVA读书笔记 运算符按位运算与(&)两个操作数中位都为1,结果才为1,否则结果为0或(|)两个位只要有一个为1,那么结果就是1,否则就为0非(~)如果位为0,结果是1,如果位为1,结果是0亦或(^)两个操作数的位中,相同则结果为0,不同则结果为1。移位运算符左移运算符(<<)num << a,相当于num乘以2^a10 <<2=40 1010<<2=101000 右移运算符(>>)num >> a,相当于num 阅读详情

think in java

数据存储

  • 寄存器:最快的存储区,位于存储器内部,数量及其有限,无法直接控制
  • 堆栈:
  • 堆:
  • 常量存储:存代码中或ROM(只读存储器,例:字符串池)
  • 非RAM存储:文件或者数据库数据等

特列:基本类型 存于堆栈中使程序变得更高效

基本类型大小最小值最大值包装器类型
boolean---Boolean
char16bitUnicode 0Unicode 216 - 1Character
byte8bits-128+127Byte
short16bits-215215-1Short
int32bits-231231-1Integer
long64bits-263263-1Long
float32bitsIEEE754IEEE754Float
double64bitsIEEE754IEEE754Boolean
void---Void

main方法

public static void mian(String[] args){
}

参数args虽然未用到,但是java编译器要求必须这样做,因为args要用来存储命令行参数。

基本类型转换

  • 窄化转换:需要显示声明转换,不然编译器会报错
  • 扩展转换:编译器自动转换,无需显示声明
  • java允许基本类型转换成别的任何基本类型,boolean类型除外

对基本类型数据类型执行算数运算或者按位运算,只要比int小,在运算前会自动转换为int类型

this关键字的本质

java中调用类中的某个方法(非静态)时,编译器会隐式的将调用该方法的对象实列作为方法的第一个参数传入,此时若方法中需要用到当前调用方法的对象实列,就可以通过this关键字获取。
静态方法则不存在隐式传参,这也就是为什么静态方法里面不能调用非静态方法的原因。静态方法中无法获取到当前调用对象实列(this)

相比较于c++,java不需要开发者销毁对象(释放空间),而对象的销毁由java虚拟机(垃圾回收器)来完成。虚拟机要实现这样的功能,那么虚拟机就需要知道对象是如何创建的,内存上是存在来哪里,这样虚拟机才知道如何去释放这些对象内存。而这就要借助构造函数。

构造函数

构造函数存在的重大意义在于Java虚拟机通过构造函数统一创建对象。这为虚拟机之后对对象销毁内存回收创造了条件。(谁创建的谁销毁,解铃还须系铃人)

finalize()方法

垃圾回收器在认为某个对象满足回收条件后,会调用一次finalize()方法,下一次回收时才会回收这个对象。

  • 虚拟机负责java对象的创建与销毁,但有一部分内存但使用虚拟机是没法感知并回收的(本地方法中使用到的内存)。这时候,在销毁回收对象时,就需要开发者告诉虚拟机如何回收这部分内存。这就是finalize()方法的用法之一。
  • 有的对象销毁回收前,虚拟机认为该对象可以销毁,但是开发者还需要用这个对象,还不想回收销毁。这时就可以在finalize()方法里面阻止虚拟机销毁回收该对象

垃圾回收机制

垃圾回收主要工作:清除无用对象回收其所占内存,使内存循环利用;使内存有序分配,减少内存碎片,提高创建对象效率。

回收基本原理

  • 停止-复制:停止程序,将所有存活的对象复制到另一个堆,没有被复制的全都是垃圾。当对象复制到新堆后,是一个挨着一个的,所有新堆保持紧凑排序。
    缺点:1.占用内存大,需要消耗实际内存的两倍。针对这个问题按需从堆中分配几块较大的内存块,复制动作在这些大块内存之间(分代收集);2.程序进入稳定状态后,垃圾往往很少。这样两个堆之间来回捣腾,非常浪费性能。针对这个问题,引入了标记-清扫方案
  • 标记-清扫:从堆栈和静态存储区出发,遍历所有引用,进而找出所有存活的对象。每当找到一个存活的对象,就会给对象设一个标记,这个过程中不会回收任何对象。只有全部标记工作完成的时候,清理动作才开始。清理过程中,没有被标记的对象将会被释放。
    缺点:1.速度非常慢,但是只会产生少量垃圾甚至不会产生垃圾时,速度就很块了;2.回收完成后,剩下的堆空间是不连续的,垃圾回收器要是希望得到连续空间的话,就得重新整理剩下的对象。

前文说述,Java虚拟机中,内存分配为较大的块。如果对象较大,会占用单独的块。停止-复制回收内存时,这些大的内存块不会被复制。每个块都有相应的代数来记录它是否存活,每有一处引用时,计数块会增加。
java虚拟机有内存监控机制,当内存碎片过多时采用停止-复制算法;程序趋于稳定,不再产生大量的垃圾时,用标记-清扫算法。如此配合往复回收。

成员初始化

初始化顺序:静态变量成员初始化 ——> 非静态成员初始化(默认值)——>构造器赋值

对象创建过程

Created with Raphaël 2.3.0 开始 1.解释器查询类路径,定位.class文件 2.加载.class文件,创建一个Class对象,静态初始化(静态常量) 3.new 创建对象时,堆上分配足够的空间 4.分配的空间清零,将成员变量设置成默认值 5.执行所有字段定义处的初始化动作 6.执行构造器 结束

前2步只有在对象首次创建的时候才执行

访问权限控制

  • public
  • protected 同包 + 子类
  • 默认 同包
  • private

多态

运行时绑定、动态绑定、后期绑定

继承

基类私有/final方法不能被覆盖,即使导出类虽然也可以有相同的方法。
基类的成员变量不会被导出类成员变量覆盖

public class Parent {

     private final String print(){
        return "Parent";
     }
}

public class Child extends Parent{
	//不会报错,因为基类私有,两个不在一个域,即使方法名一样也不会报错
     public void print(){
       
     }
}

多接口实现问题

同时实现多个接口,多个接口中含有相同的方法名,只是返回类型不同,则编译报错

interface a{
int f();
}
interface b{
void f();
}
class c implements a,b{
//不管返回类型是void还是int都会报错
void f();
}

java类图

  1. 类图域的表示
    [+] ---->public
    [-] ---->private
    [#] ---->protected

  2. 类之间的关系表示

  • 关联(B关联A)
A B +A a 关联
class A{

}

class B{
	public A a;
}

  • 组合(A组合B,需要注意的是,B的生命周期和A是绑定的)
B A
class A{
	class B{}
}

  • 聚合(A聚合B)
B A
class A {
  List<B> b;
}

class B{

}

  • 泛化(继承)
A B
class A{
}

class B extends A{

}
  • 实现
«interface» A B
interface A{
}
class B implements A{
}

String

String a="buffer";
String b = a + "sdjf";

for(int i=0;i<10;i++){
	a += i
}
StringBuilder a1 = new StringBuilder(a);
for(int i=0;i<10;i++){
	a1.append(i);
}

编译器在编译时会生成一个StringBuilder对象来优化计算效率。因此简单的字符串拼接我们可以直接用+号。复杂的字符串拼接(循环拼接字符串)时,虽然编译器也会借助StringBuilder来优化,但是会生成多个StringBuilder对象。而若是代码里面使用StringBuilder则是生成一个StringBuilder对象。

jdk动态代理

public interface Interface {

    void doSomething();

    void somethingElse(String args);
}

/**被代理的类
 * @author jinWen Wang
 * @date 2021年08月02日 16:29
 */
public class RealObject implements Interface{

    @Override
    public void doSomething() {
        System.out.println("RealObject doSomething");
    }

    @Override
    public void somethingElse(String args) {
        System.out.println("RealObject somethingElse  "+args);
    }
}

/** 动态代理类
 * @author jinWen Wang
 * @date 2021年08月02日 14:57
 */
public class DynamicProxy implements InvocationHandler {

    private final Object proxied;

    public DynamicProxy(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("***** proxy: "+proxy.getClass()+". method: "
        +method + ".args: " + Arrays.toString(args));

        if(args != null){
            for (Object arg : args) {
                System.out.println("  "+arg);
            }
        }

        return method.invoke(proxied,args);
    }
}

/**
 * @author jinWen Wang
 * @date 2021年08月02日 16:23
 */
public class SimpleDynamicProxy {

    public static void consumer(Interface iface){
        iface.doSomething();
        iface.somethingElse("nnnn");
    }

    public static void main(String[] args) {
        RealObject realObject = new RealObject();

        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
                new Class[]{Interface.class},
                new DynamicProxy(realObject));

        consumer(proxy);
    }

}

调用静态方法Proxy.newProxyInstance()可以创建一个动态代理类。

  • 第一个参数是类加载器(跟Interface.class类关系不大,这里这样使用只是为了从已加载的类中获取类加载器);
  • 第二个参数是需要代理类实现的接口列表(一个类可以实现多个接口,且只能是接口,不能是类或抽象类。ps:spring AOP的jdk方式实现原理);
  • 第三个是实现了InvocationHandler接口的调用处理器。动态代理可以将所有调用重定向到调用处理器(DynamicProxy),因此需要在调用处理器的构造方法传入“真实”的对象引用,调用处理器在执行其中介任务时可以将请求转发

总结:
RealObject是被代理的类,DynamicProxy需要实现InvocationHandler接口,并在invoke方法里面做代理类需要处理的逻辑,然后转发到被代理的类。Proxy.newProxyInstance()根据以上的信息动态的生成一个代理类。

RTTI :通过匿名基类的引用来发现类型信息

class A{
	public void print(){
		System.out.print("A---A")
	}
}

class B extends A{
	public void print(){
		System.out.print("B---B")
	}
}

class test{
	public static void action(A a){
		a.print();
	}
	public static void main(String[] args){
		B b = new B();
		action(b);
		//输出:B---B
	}
}

通过匿名的基类A引用发现B类型信息,进而调用B的print()方法。

泛型类型擦除,泛型内部并没有类型区别,都是持有一个Object对象

 		  Class<?> a = new ArrayList<Integer>().getClass();
          Class<?> b = new ArrayList<String>().getClass();

          System.out.println(a == b);
          //输出 true

注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {
}

元注解
@Target 用来定义注解用于什么地方
ElementType参数包括:

  • CONSTRUCTOR — 构造器声明
  • FIELD — 域声明
  • LOCAL_VARIABLE — 局部变量声明
  • METHOD — 方法声明
  • PACKAGE — 包声明
  • PARAMETER — 参数声明
  • TYPE — 类声明,类、接口、注解或enum声明

@Retention 用来定义注解在哪一个级别可用
可选RetentionPolicy参数包括:

  • SOURCE — 源代码中
  • CLASS — 类文件中
  • RUNTIME — 运行时

@Document 将此注解包含在javadoc中

@InHerited 允许子类继承父类中的注解

java线程之后台模式(后台线程/守护线程/精灵线程)

  • 代表:jvm垃圾回收线程
  • 开启方式:调用Thread的setDaemon(true)方法
  • 特点:所有非后台线程结束,程序终止,所以进程中的后台线程会被杀死。杀死意味着守护线程的finaly也不会执行。

多线程异常捕捉处理

关键点
  • 实现Thread.UncaughtExceptionHandler接口做为异常处理器
  • 在线程中设置异常处理器
/**
 * 异常处理器
 */
public class ThreadExceptionHandler implements Thread.UncaughtExceptionHandler{

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        String name = t.getName();
        System.out.println("线程:["+name+"]发生异常");
        e.printStackTrace();
        if(e instanceof BizException){
            BizException bizException = (BizException)e;
            System.out.println("线程:["+name+"]发生异常,异常信息:"+bizException);
        }
    }
}

public class MyRunnable implements Runnable{

    final boolean exception;
    final String name;

    public MyRunnable(boolean exception, String name) {
        this.exception = exception;
        this.name = name;
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println(this.name+"["+threadName+"]开始");
        if(exception){
            System.out.println(this.name+"["+threadName+"]抛出异常");
            throw new BizException("自定义异常",name,threadName);
        }
        System.out.println(this.name+"["+threadName+"]正常结束");
    }
}

/**
*自定义异常
*/
public class BizException extends RuntimeException{

    private String name;

    private String thread;
}

/**
 * 测试类
 */
public class ThreadExceptionTest {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread t = new Thread(new MyRunnable(i%2==0,"test" + i));
            //设置异常处理器
            t.setUncaughtExceptionHandler(new ThreadExceptionHandler());
            t.start();
        }
    }

}

执行结果
在这里插入图片描述

Thread.UncaughtExceptionHandler接口是java1.5开始提供的接口,它允许再每个Thread上附着一个异常处理器。Thread.UncaughtExceptionHandler.uncaughtException()方法会在线程因未捕获的异常而临近死亡时被调用。
---------java编程思想

double/long非原子性

JVM可以将64位的读取和写入当作两个分离的32位操作来执行,这就产生读取和写入之间的上下文切换,从而导致不同的任务可以看到不正确结果的可能。这种现象也叫做字撕裂。使用volati

《Think in Java》深入理解编程指南 本文还有配套的精品资源,点击获取 简介:《Think in Java》是由Bruce Eckel编写的Java编程经典教程,为初学者和经验丰富的程序员提供全面的Java语言理解。本书以详尽的解释、丰富的示例和深入的概念分析著称,涵盖了Java基础语法、面向对象编程概念、异常处理、集合框架、泛型、IO流、多线程和网络编程等。同时,书中还强调了在线资源和社区的重要性,提供额外的... 阅读详情

相关推荐

thinkinjava源码-Think-In-Java-Code:ThinkingInJava(第四版)书中源码以及课后练习代码

think in java 源码 Think-In-Java-Code Thinking In Java 书中源码以及课后练习代码(从第7章开始随着看书的进度一步步更新) 第七章 复用类 7.1 组合语法 7.2 继承语法 7.2.1 初始化基类 7.3 代理 7.4 结合使用组合和继承 7.4.1 确保正确清理 7.4.2 名称屏蔽 7.5 在组合与继承之间选择 7.6 protected关键字 7.7 向上转型 7.7.2 再论组合与继承 7.8 final关键字 7.8.1 final 数据 7.8.2 final 方法 7.8.3 final 类 7.9 初始化以及类的加载 7.9.1 继承与初始化 第八章 多态 8.1 再论向上转型 8.2 转机 8.2.2 产生正确的行为

探索Java编程艺术:Think in Java项目详解

探索Java编程艺术:Think in Java项目详解 在编程的世界中,Java一直以其稳定性、可移植性和强大的库支持占据着重要的位置。今天,我们要介绍一个名为“Think in Java”的开源项目,它旨在帮助开发者深入理解Java编程思想并提升技能。该项目可以在上找到。 项目简介 “Think in Java”是由开发者Quanke编写的,灵感来源于经典的《Thinking in Java》...

gitblog_00027的博客 594

pentaho-kettle依赖拉取失败?试试这个Maven仓库配置的终极解决方案

本文详细解析了Pentaho Kettle依赖拉取失败的常见原因,并提供了三种Maven仓库配置方案,包括基础pom.xml配置、全局settings.xml设置以及企业级私有镜像仓库搭建。通过实战验证的方法和常见问题排查指南,帮助开发者彻底解决pentaho-kettle依赖问题,提升项目构建效率。

weixin_30275415的博客 205

think in java_Think in java笔记(一)

Introduction to Objects & Everything is an Objects1.万物皆对象2.upcast是安全的3.downcast不是绝对安全的,SE5之前,由于容器类只能容纳Object,所以当你将一个对象引用丢进容器,这个对象就upcast成Object,丢失了原有的信息。4.但是SE5允许利用generics(泛型)可以安全地downcast S例如Arr...

weixin_42521032的博客 435

Transformer凭什么取代RNN?深入拆解自注意力机制与梯度消失问题的终极对决

本文深入探讨了Transformer如何通过自注意力机制解决RNN的梯度消失问题,成为自然语言处理领域的新标准。通过对比RNN和Transformer的架构差异,揭示了自注意力机制在并行计算、长期依赖处理等方面的技术优势,并提供了实际任务中的性能对比数据。

f6g7h8i9j的博客 191

YOLOv5 改进点总览:轻量化、高精度的背后有哪些魔改?

YOLOv5是由Ultralytics团队开发的高效目标检测模型,其核心改进包括:主干网络采用CSPDarknet53提升梯度传播效率;特征融合使用PANet增强小目标识别;输出结构采用解耦头设计优化定位和分类任务。此外,YOLOv5通过CIoU损失函数、Mosaic数据增强和SimOTA标签分配机制进一步提升性能。模型支持多种推理格式(ONNX/TensorRT等),并具备自动锚框匹配和多尺度训练功能,使其在轻量化(yolov5s仅7MB)与高性能(最高51.2% mAP)间取得平衡,但缺乏正式论文支撑是

guoguozgw的博客 1806

《Think in Java》

java的一个优点就是,一开始就内置了异常处理,并且强制程序员必须去使用,java将异常也当作一种对象,从错误的地点抛出,异常不能被忽略,必须在程序运行的某处得到处理,被专门设计用来处理特定类型错误的异常处理器捕获,异常处理就像和程序运行并行的,错误发生时执行另一个路径,不会干扰正常代码的执行。比如我们向circle类发送请求,我们就将其当成shape类,我们不需要关系其所属的特定类,因为所有shape子类都实现了shape类的绘制,擦除与移动的方法,我们不需要担心其如何实现。第二是出于效率原因。

qq_35693377的博客 775

Linux 音频驱动(六) ALSA音频驱动之PCM Write数据传递过程

目录1. 前言2. PCM Data Flow3. 总结 1. 前言 本文,我们将以回放(Playback,播放音频)为例,讲解PCM Data是如何从用户空间到内核空间,最后传递到Codec。 在Linux 音频驱动(一) ASoC音频框架简介中,我们给出了回放(Playback)PCM数据流示意图: 对于Linux来说,由于分为 user space 和kernel space,而且两者之间不能随便互相访问。因此用户如果播放音频,则需要调用copy_from_user()将用户数据从user spa

_Modest_的博客 1万+

Think in Java 读书笔记(一)(浓缩出精华_(:з)∠)_)

最近需要整理一堆资料,在即将回到学校的日子里略显迷茫,先从自己读书笔记开始整理把~下面是Think in java 的读书笔记,希望這篇文章能够作为一个好的开端。 第一章OOP 1、OOP 2、每个对象都提供服务(当正在开发或理解一个程序设计时,最好的方法就是将对象想象为服务提供者) 3、程序猿按照角色可分别为类创建者和客户端程序猿。 4、代码复用是面向对象程序设计语言所提供的最了不起的

泡泡茶壶的博客 922

从零开始学习CANoe(六)—— CAPL 测试节点

创建CAPL Test Module的两种方式

蚂蚁小兵 1万+

消灭 qRFC 队列 Generic stop 错误——SAP CRM 中间件 SMQ1 排障与根因分析全景指南

并不可怕,可怕的是缺乏对 qRFC 状态机的整体把握。通过本文,你不仅看到一个简单的“删表记录就好”的技巧,还能理解:为什么系统要用通用停用而不是显示具体错误;如何定位sg_lock的赋值源头;如何借助监控把被动救火变为主动防火。下一次当 SMQ1 再次闪红,你只需从容执行本文提到的排障脚本,就能把停着的队列重新拉上正轨。参考文献SAP 社区博客 “An example to fix Generic stop set error status in tcode SMQ1”(STOP。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 812

Think in java读书笔记

Think in java读书笔记(在网上找了好久,现在总结起来放在上面,方便大家查看)第一章:对象简介1、Java的五大特征,也是面向对象的五大特征:   Everything is an object:万物皆对象   A program is a bunch of objects telling each other what to do by sending messages:程序就

方健的博客 1551

2025年11月架构设计师综合知识真题回顾,附参考答案、解析及所涉知识点(二)

本文整理了2025年11月架构设计师考试的16-30题真题及解析,涵盖多个计算机系统知识领域。主要内容包括:Linux绝对路径以根目录开始(A);模块调用下层数量用扇出表示(B);游乐园问题通过集合运算得出10人未游玩(B);磁盘位示图计算为200字节(C);测试用例核心是输入与预期输出(D)。其他题目涉及软件可靠性测试概念(B错)、评价程序准确度排序(真实程序最高,A)、测试阶段顺序(单元→组装→系统,A)、Web服务器压力测试前置步骤(C)、分时系统响应时间影响因素(用户数量多,A)、逆向工程方法(基于

一几文的编程学习笔记。 230

Think in Java 异常类(第12章) 读书笔记

概念: 首先看一下Java中的异常体系: Error:一般是指与虚拟机相关的问题,如 OOM,ThreadDeath。 RuntimeExprion:NullPointerException,ClassCastException,IllegalArgumentException,ArrayStoreException,IndexOutOfBoundsException,Num...

ltx0720的博客 353

【温室气体数据集】CAMS 发布的温室气体(GHG)数据集总结

【温室气体数据集】CAMS 发布的温室气体(GHG)数据集总结

WW、forever的博客 556

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

think in java 读书笔记

think in java 第四版 普通内部类,不能有staic数据和字段 猜想:外部类会根据字段和方法决定编译或运行时期内存分配,内部类作为其中一部分,一旦被决定,无法修改,所以内部类若不是静态,里边不能有static修饰的字段和方法 Foreach:collection能用foreach是因为Iterable接口(1.5引进)的iterator()方法,任何一个类实现了Iterable,都可...

PangQiuu的博客 383

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Think In Java 读书笔记

一直想写一个关于Java的读书系列帮助自己梳理知识总是无从开始,最近把Think In Java 又重新看了一遍决定写个读书笔记关于Java的值传递与引用传递一直以来关于Java是值传递还是引用传递都是争论不断,一种观点认为Java中只有值传递,另一种观点认为Java有值传递和引用传递两种,其实只是说法不同。 说只有值传递是将参数为应用的情况时传递的应用当成一种特殊值,而说值传递和引用传递都有的观

ktzhep的博客 238

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

读书笔记《think in Java》①

think in Java 第一章 1.1抽象 所有东西都是对象。对象里面保存着数据,对象可以对自己进行操作。 程序包含许多对象。通过消息传递调用对象。 每个对象都有自己的存储空间,可以封装其他对象生成新对象。 每个对象都有一直类型,都是类的实例,能够接受不同类型的消息。 同类对象能接收相同的消息——对象的【可替代性】。 1.2对象的接口 “类型”决定了接口,而“类”是那个接口的一种特殊实现方式。 1.3实现方案的隐藏 “public”(公共)意味着后续的定义任何人均可使用。 “private”(私有

SherlockerSun的博客 339

Think in Java 读书笔记(1)

Think in java 那个是2008年买的,断断续续看了一下。没有系统的全部看完,以前看的很多都忘记了,打算利用最经一段时间来全面系统的看一下。并将自己理解的一些东西记录到博客,方便一下初学中吧。

yuwenruli的专栏 716

think in java笔记_Thinking in java读书笔记 PDF 下载

主要内容:第一章对象导论1. 因为类描述了具有相同特征(数据元素、静态)和行为(功能、动态)的对象集合。public表示紧随其后的元素对任何人都是可用的,而private这个关键字表示除类型创建者和类型的内部方法之外的任何人都不能访问的元素。Private就像你与客户端程序之前的一堵砖墙,如果有人试图访问private成员,就会在编译时得到错误信息。篇protected关键字与private作用相...

weixin_39765280的博客 259

Think in java 读书笔记

第二章:一切皆对象2.1:类 又称为对象的类型!2.2: 本书中,谈到‘类型’都是指class      对象的类型 说的是class  !  new class() 是类型实例化出来的对象!2.3: 对象的类型是class , class的类型是Class,俗称类类型2.4:执行new 来创建对象时,数据存储空间才被分配!  第八章:多态8.1:向上转型:对象即可作为它自己本身的类型使用,也可作...

qq_29425387的博客 208
上一篇: idea查看源码常备快捷键
下一篇: 【leetcode】正则表达式匹配
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

搬砖工-->攻城狮

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

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

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

打赏作者

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

抵扣说明:

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

余额充值