Java文字值分配行为（java文字类型）

25-03-18 9

关于Java文字值分配行为和java文字类型的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于c–文字值的范围是什么,编译器如何为其分配内存？、java编译java文件以及生成可执行jar、

关于Java文字值分配行为和java文字类型的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于c – 文字值的范围是什么,编译器如何为其分配内存？、java 编译java文件以及生成可执行jar、Java 静态多分配，动态单分配、Java-将数组值分配给各个变量的快速方法等相关知识的信息别忘了在本站进行查找喔。

本文目录一览：

Java文字值分配行为（java文字类型）
c – 文字值的范围是什么,编译器如何为其分配内存？
java 编译java文件以及生成可执行jar
Java 静态多分配，动态单分配
Java-将数组值分配给各个变量的快速方法

Java文字值分配行为（java文字类型）

在Kathy Sierra撰写的SCJP指南书中的作业一章中，我们了解到可以声明这样的内容byte b = 7;。幕后的代码是byte b =(byte) 7;。之所以如此，是因为在Java中，数字7被认为是文字int值，因此必须转换为int。

现在其他情况。Double可以包含浮点值中包含的每个字节，因为它是更大的数据类型。所以我们可以说float f =10.543;10.543是一个很小的值，应该适合浮点数。该数字的文字值也被视为Double，因此编译器应隐式将其强制转换为float。但是事实并非如此，编译器阻止了我们。我们必须在该值后附加F或f。

为什么在字面值分配中存在这两个冲突的行为？简而言之，如果byte b = 7可能的话。为什么float f = 10.543不可能呢？

答案1

小编典典

您可以阅读JLS
5.2分配转换

常量的编译时范围缩小意味着代码如下：

 byte theAnswer = 42;

被允许。如果不进行缩小，则整数文字42具有int类型的事实意味着将需要强制转换为字节：

byte theAnswer = (byte)42;  // cast is permitted but not required

如果表达式的类型不能通过赋值上下文中允许的转换转换为变量的类型，则会发生编译时错误。
如果变量的类型为float或double，则将值集转换（第5.1.13节）应用于值v

JLS＃3.10.2。浮点文字

如果浮点文字后缀为ASCII字母F或f，则其类型为float。否则，其类型为double，并且可以选择在其后缀ASCII字母D或d

5.1.2。扩大原始转换

从double到float的原始转换变窄由IEEE
754舍入规则（第4.2.4节）控制。这种转换可能会失去精度，但也会失去范围，导致非零双精度浮点为零，而有限双精度浮点为无穷大。双精度NaN转换为浮点型NaN，双精度无穷大转换为相同符号的浮点无穷大。

我希望以上能澄清您的疑问。

c – 文字值的范围是什么,编译器如何为其分配内存？

int x = 12;

12表示是整数字面值,因此不能用于LValue.

>编译器如何为文字分配内存？
>文字的范围是什么？
>为什么我们不能在其范围内使用& 12获得其地址？

解决方法

好问题中的错误示例.
但问题仍然有效：
我们试试吧：

Foo getFoo() {return Foo();}

int func()
{
    getFoo().bar();   // Creates temporary.
    // before this comment it is also destroyed.
    // But it lives for the whole expression above
    // So you can call bar() on it.
}

int func2()
{
    Foo const& tmp = getFoo();  // Creates temporary.
                                // Does not die here as it is bound to a const reference.

    DO STUFF
}  // tmp goes out of scope and temporary object destroyed.
   // It lives to here because it is bound to a const reference.

How does the compiler allocate memory to a temporary object?

未定义到编译器.
但是在堆栈帧上分配更多的内存并将其保存在那里真的很容易.然后销毁它并减小堆栈帧的大小(尽管这个答案对你不应该做的底层硬件做了很多假设(最好只把它想象为编译器做魔术)).

What is the scope of a temporary object?

临时对象一直存在到表达式的末尾(通常是;),除非它绑定到const引用.如果它绑定到const引用,那么它仍然存在于引用所属范围的末尾(有一些例外(如构造函数)).

Why can’t we get its address with an &12 in its scope?

在问题12中不是临时对象.它是一个整数字面值.

java 编译java文件以及生成可执行jar

1.新建java project:

2.src下新建包以及class文件：

3.打包：

5.选取目标mainclass 很关键决定jar是否可执行：

7.build jar :

8:artifact jar:

9：执行jar:

10:重新编译 test.java:

11：recompile class保存位置：

Java 静态多分配，动态单分配

OSC 请你来轰趴啦！1028 苏州源创会，一起寻宝 AI 时代

class Human{
}  
class Man extends Human{
}
class Woman extends Human{
}

public class StaticPai{

	public void say(Human hum){
		System.out.println("I am human");
	}
	public void say(Man hum){
		System.out.println("I am man");
	}
	public void say(Woman hum){
		System.out.println("I am woman");
	}

	public static void main(String[] args){
		Human man = new Man();
		Human woman = new Woman();
		StaticPai sp = new StaticPai();
		sp.say(man);
		sp.say(woman);
	}
}

总结：Human man = new Man（）; 我们把上面代码中的 “Human” 称为变量的静态类型，后面的 “Man” 称为变量的实际类型。静态类型和实际类型在程序中都可以发生一些变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译期可知的，而实际类型变化的结果在运行期才可确定。回到上面的代码分析中，在调用 say（）方法时，方法的调用者（回忆上面关于宗量的定义，方法的调用者属于宗量）都为 sp 的前提下，使用哪个重载版本，完全取决于传入参数的数量和数据类型（方法的参数也是数据宗量）。代码中刻意定义了两个静态类型相同、实际类型不同的变量，可见编译器（不是虚拟机，因为如果是根据静态类型做出的判断，那么在编译期就确定了）在重载时是通过参数的静态类型而不是实际类型作为判定依据的。并且静态类型是编译期可知的，所以在编译阶段，Javac 编译器就根据参数的静态类型决定使用哪个重载版本。这就是静态分派最典型的应用。

class Eat{
}
class Drink{
}

class Father{
	public void doSomething(Eat arg){
		System.out.println("爸爸在吃饭");
	}
	public void doSomething(Drink arg){
		System.out.println("爸爸在喝水");
	}
}

class Child extends Father{
	public void doSomething(Eat arg){
		System.out.println("儿子在吃饭");
	}
	public void doSomething(Drink arg){
		System.out.println("儿子在喝水");
	}
}

public class SingleDoublePai{
	public static void main(String[] args){
		Father father = new Father();
		Father child = new Child();
		father.doSomething(new Eat());
		child.doSomething(new Drink());
	}
}

总结：儿子在喝水
我们首先来看编译阶段编译器的选择过程，即静态分派过程。这时候选择目标方法的依据有两点：一是方法的接受者（即调用者）的静态类型是 Father 还是 Child，二是方法参数类型是 Eat 还是 Drink。因为是根据两个宗量进行选择，所以 Java 语言的静态分派属于多分派类型。
再来看运行阶段虚拟机的选择，即动态分派过程。由于编译期已经了确定了目标方法的参数类型（编译期根据参数的静态类型进行静态分派），因此唯一可以影响到虚拟机选择的因素只有此方法的接受者的实际类型是 Father 还是 Child。因为只有一个宗量作为选择依据，所以 Java 语言的动态分派属于单分派类型。

Java-将数组值分配给各个变量的快速方法

我有一种方法，split(str, ":", 2)确切地说，它将在数组中返回两个字符串。

java中是否有比将数组中的两个值分配给字符串变量更快的方法？

String[] strings = str.split(":", 2);String string1 = strings[0];String string2 = strings[1];

例如是否有类似的语法

String<string1, string2> = str.split(":", 2);

提前致谢。

答案1

小编典典

不，Java中没有这样的语法。

但是，其他一些语言也具有这种语法。示例包括Python的元组解包，以及许多功能语言中的模式匹配。例如，在Python中，您可以编写

 string1, string2 = text.split('':'', 2) # Use string1 and string2

或在F＃中，您可以编写

 match text.Split([| '':'' |], 2) with | [string1, string2] -> (* Some code that uses string1 and string2 *) | _ -> (* Throw an exception or otherwise handle the case of text having no colon *)

关于Java文字值分配行为和java文字类型的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于c – 文字值的范围是什么,编译器如何为其分配内存？、java 编译java文件以及生成可执行jar、Java 静态多分配，动态单分配、Java-将数组值分配给各个变量的快速方法的相关信息，请在本站寻找。

本文标签：