Chuyển đổi biểu đồ sang int java. Chuyển đổi loại rõ ràng

Chú thích: Bài giảng này dành cho các vấn đề về chuyển đổi kiểu. Vì Java là một ngôn ngữ được đánh máy mạnh, trình biên dịch và máy ảo luôn theo dõi loại để đảm bảo rằng chương trình chạy một cách đáng tin cậy. Tuy nhiên, trong nhiều trường hợp, một hoặc một phép biến đổi khác là cần thiết để thực hiện logic của chương trình. Mặt khác, một số băng qua đường an toàn Giữa các kiểu Java cho phép nhà phát triển thực hiện một cách ngầm định, điều này có thể dẫn đến hiểu lầm về cách thức hoạt động của chương trình. Bài giảng thảo luận về tất cả các loại phép biến hình, và sau đó là tất cả các tình huống trong chương trình mà chúng có thể được áp dụng. Nó kết thúc bằng cách bắt đầu phân loại các loại biến và loại giá trị mà chúng có thể lưu trữ. Vấn đề này sẽ được thảo luận chi tiết hơn trong các bài giảng tiếp theo.

Tất cả điều này có nghĩa là gì? Hãy bắt đầu theo thứ tự. Vì loại đơn giản mở rộng có nghĩa là có sự chuyển đổi từ loại ít dung lượng hơn sang loại có dung lượng lớn hơn. Ví dụ, từ kiểu byte (độ dài 1 byte) sang kiểu int (độ dài 4 byte). Những chuyển đổi như vậy là an toàn theo nghĩa là kiểu mới luôn được đảm bảo chứa tất cả dữ liệu đã được lưu trữ ở kiểu cũ và do đó không xảy ra mất mát dữ liệu. Đó là lý do tại sao trình biên dịch tự triển khai nó, không được nhà phát triển chú ý:

byte b = 3; int a = b;

Ở dòng cuối cùng, giá trị byte của b sẽ tự động được chuyển đổi thành a (tức là int); không cần thực hiện bước đặc biệt nào.

19 phép biến đổi sau đang mở rộng:

byte sang short, int, long, float, double
ngắn đến int, dài, float, gấp đôi
từ char sang int, long, float, double
int đến long, float, double
dài để nổi, gấp đôi
nổi lên gấp đôi

Lưu ý rằng bạn không thể chuyển đổi thành char từ nhỏ hơn hoặc chiều dài bằng nhau(byte, short), hoặc ngược lại, viết tắt từ char mà không bị mất dữ liệu. Điều này là do char, không giống như các kiểu số nguyên khác, không có dấu.

Tuy nhiên, cần nhớ rằng ngay cả khi mở rộng, dữ liệu vẫn có thể bị hỏng trong những trường hợp đặc biệt. Chúng đã được xem xét trong bài giảng trước, đây là ép giá trị int sang kiểu float và ép giá trị dài sang kiểu float hoặc double. Mặc dù các loại phân số này có thể chứa nhiều số lượng lớn hơn các số nguyên tương ứng, nhưng chúng có ít chữ số có nghĩa hơn.

Hãy lặp lại ví dụ này:

dài a = 111111111111L; float f = a; a = (dài) f; in (a);

Kết quả sẽ là:

Sự chuyển đổi nghịch đảo - thu hẹp - có nghĩa là quá trình chuyển đổi được thực hiện từ loại có dung lượng nhiều hơn sang loại ít dung lượng hơn. Với việc chuyển đổi như vậy sẽ có nguy cơ mất dữ liệu. Ví dụ, nếu số thuộc loại int lớn hơn 127, thì khi nó được truyền thành byte, giá trị của các bit cũ hơn bit thứ tám sẽ bị mất. Trong Java, việc chuyển đổi này phải được thực hiện một cách rõ ràng, tức là lập trình viên trong mã phải chỉ ra rõ ràng rằng anh ta dự định thực hiện chuyển đổi như vậy và sẵn sàng mất dữ liệu.

Các chuyển đổi sau đang thu hẹp:

byte thành ký tự
ngắn thành byte, ký tự
char thành byte, ngắn
int sang byte, short, char
dài thành byte, ngắn, ký tự, int
float thành byte, short, char, int, long
từ kép sang byte, short, char, int, long, float

Khi thu hẹp một kiểu số nguyên thành một kiểu số nguyên hẹp hơn, tất cả các bit bậc cao không phù hợp với kiểu mới sẽ bị loại bỏ một cách đơn giản. Không làm tròn số hoặc các hành động khác được thực hiện để thu được kết quả chính xác hơn:

print ((byte) 383); print ((byte) 384); print ((byte) -384);

Kết quả sẽ là:

Có thể thấy rằng bit dấu hiệu không có tác dụng trong quá trình thu hẹp, vì nó chỉ đơn giản là bị loại bỏ - kết quả của việc chuyển đổi các số đối diện (384 và -384) hóa ra là giống nhau. Do đó, không chỉ chính xác giá trị tuyệt đối, mà còn là dấu hiệu của độ lớn.

Điều này cũng đúng với thuộc loại char :

char c = 40000; in ((ngắn) c);

Kết quả sẽ là:

Giảm một kiểu phân số thành một kiểu số nguyên phức tạp hơn. Nó được thực hiện trong hai giai đoạn.

Trong bước đầu tiên, giá trị phân số được chuyển đổi thành long nếu kiểu đích là dài hoặc thành int nếu không, (kiểu đích là byte, short, char hoặc int). Đối với điều này, ban đầu Số phân sốđầu tiên được làm tròn về mặt toán học về 0, nghĩa là phần nhỏ chỉ đơn giản là bị loại bỏ.

Ví dụ: 3,84 sẽ được làm tròn thành 3 và -3,84 sẽ trở thành -3. Trong trường hợp này, các trường hợp đặc biệt có thể phát sinh:

nếu giá trị phân số ban đầu là NaN, thì kết quả của bước đầu tiên sẽ là 0 của kiểu đã chọn (tức là int hoặc long);
nếu giá trị phân số ban đầu là dương hoặc âm vô cùng, thì kết quả của bước đầu tiên sẽ tương ứng là giá trị lớn nhất hoặc nhỏ nhất có thể cho kiểu đã chọn (tức là cho int hoặc long);
cuối cùng, nếu giá trị phân số là một giá trị hữu hạn, nhưng là kết quả của việc làm tròn, một số quá lớn về giá trị tuyệt đối đối với kiểu đã chọn (tức là đối với int hoặc long), thì, như trong đoạn trước, kết quả của bước đầu tiên tương ứng sẽ là giá trị lớn nhất hoặc nhỏ nhất có thể có của loại này. Nếu kết quả làm tròn phù hợp với phạm vi giá trị của kiểu đã chọn, thì nó sẽ là kết quả của bước đầu tiên.

Kết luận, một lần nữa thu hút sự chú ý đến thực tế là các giá trị nguyên thủy của kiểu boolean chỉ có thể tham gia vào các chuyển đổi giống hệt nhau.

Đôi khi các tình huống phát sinh khi bạn có giá trị của một số thuộc một loại nhất định, và bạn cần gán nó cho một biến có kiểu khác. Đối với một số kiểu, điều này có thể được thực hiện mà không cần chuyển đổi kiểu, trong những trường hợp như vậy, chúng tôi nói đến chuyển đổi kiểu tự động. Trong Java, chỉ có thể thực hiện chuyển đổi tự động nếu độ chính xác của biến đích đủ để lưu trữ giá trị ban đầu... Một chuyển đổi như vậy xảy ra, ví dụ, khi nhập một hằng số hoặc giá trị theo nghĩa đen loại biến byte hoặc viết tắt của một biến kiểu int. Nó được gọi là sự mở rộng (mở rộng) hoặc là tăng (khuyến mãi), vì kiểu có độ sâu bit thấp hơn sẽ được mở rộng (tăng tỷ lệ) thành kiểu tương thích lớn hơn. Kích thước của kiểu int luôn đủ để lưu trữ các số trong phạm vi cho phép đối với kiểu byte, do đó, trong những trường hợp như vậy, toán tử ép kiểu rõ ràng là không cần thiết. Điều ngược lại không đúng trong hầu hết các trường hợp, vì vậy bạn phải sử dụng toán tử ép kiểu để chuyển một giá trị int vào một biến byte. Thủ tục này đôi khi được gọi là thu hẹp (thu hẹp), bởi vì bạn đang yêu cầu người dịch chuyển đổi giá trị một cách rõ ràng để phù hợp với một biến kiểu bạn muốn. Để truyền một giá trị cho một kiểu cụ thể, bạn cần chỉ định kiểu này, đặt trong dấu ngoặc đơn, trước nó. Đoạn mã sau thể hiện truyền từ nguồn (biến kiểu int) sang kiểu đích (biến kiểu byte). Nếu trong quá trình hoạt động như vậy, giá trị số nguyên nằm ngoài phạm vi cho phép đối với kiểu byte, nó sẽ được giảm bớt bằng cách chia modulo cho phạm vi được phép cho byte (kết quả của việc chia modulo cho một số là phần còn lại của phép chia cho số này) ,

int a = 100;
byteb = (byte) a;

2.2.1. Chuyển đổi kiểu tự động trong biểu thức

Khi đánh giá giá trị của một biểu thức, độ chính xác cần thiết để lưu trữ các kết quả trung gian thường cần cao hơn độ chính xác cần thiết để biểu thị kết quả cuối cùng,

byte a = 40;
byte b = 50;
byte với = 100;
int d = a * b / s;

Kết quả của biểu thức trung gian (a * b) có thể nằm ngoài phạm vi giá trị cho phép đối với kiểu byte. Đây là lý do tại sao Java tự động chuyển từng phần của biểu thức thành int, do đó có đủ chỗ cho kết quả trung gian (a * b).

Chuyển đổi kiểu tự động đôi khi có thể gây ra thông báo lỗi người dịch không mong muốn. Ví dụ, đoạn mã được hiển thị bên dưới, mặc dù có vẻ khá chính xác, nhưng dẫn đến thông báo lỗi trong giai đoạn dịch. Trong đó, chúng tôi đang cố gắng viết giá trị 50 * 2, giá trị này sẽ hoàn toàn phù hợp với kiểu byte, vào một biến byte. Nhưng do tự động chuyển đổi kiểu kết quả thành int, chúng tôi nhận được thông báo lỗi từ trình dịch - sau cùng, khi int được nhập vào byte, có thể xảy ra mất độ chính xác.

byte b = 50;
b = b * 2:
^ Loại không tương thích cho =. Cần ép kiểu rõ ràng để chuyển int thành byte.
(Loại không tương thích cho =. Yêu cầu chuyển đổi rõ ràngint vàobyte)

Văn bản đã sửa:
byteb = 50;
b = (byte) (b * 2);

khiến b nhập giá trị đúng là 100.

Nếu một biểu thức sử dụng các biến kiểu byte, short và int, thì kiểu của toàn bộ biểu thức sẽ tự động được thăng cấp thành int để tránh tràn. Nếu kiểu của ít nhất một biến trong biểu thức là dài, thì kiểu của toàn bộ biểu thức cũng được thăng cấp thành dài. Hãy nhớ rằng tất cả các ký tự số nguyên không kết thúc bằng L (hoặc 1) đều là int.

Nếu biểu thức chứa các toán hạng kiểu float, thì kiểu của toàn bộ biểu thức sẽ tự động được thăng cấp thành float. Nếu ít nhất một trong các toán hạng có kiểu double, thì kiểu của toàn bộ biểu thức được thăng cấp thành double. Theo mặc định, Java coi tất cả các ký tự dấu phẩy động là kép. Chương trình sau đây cho biết kiểu của mỗi giá trị trong biểu thức được thăng cấp như thế nào để khớp với toán hạng thứ hai của mỗi toán tử nhị phân.

Lớp học Thúc đẩy (
public static void main (String args) (
byte b = 42;
char với= "a";
quần đùi = 1024;
int i = 50000;
float f = 5,67f;
nhân đôi = .1234;
kết quả kép = (f * b) + (i / c) - (d * s);
Hệ thống, ra ngoài. println ((f * b) + "+" + (i / c) + "-" + (d * s));
Hệ thống, ra ngoài. println ("result =" + kết quả); )
}

Biểu thức con f * b là một số thực được nhân với một byte, do đó, nó sẽ tự động được thăng cấp thành số thực. Biểu thức con sau i / c (int chia cho char) được thăng cấp thành int. Tương tự như vậy, loại biểu thức con d * s (gấp đôi thời gian ngắn) được thăng cấp lên gấp đôi. Trong bước tiếp theo của phép tính, chúng ta xử lý ba kết quả trung gian của các kiểu float, int và double. Đầu tiên, khi hai đầu tiên được thêm vào với nhau, kiểu int được thăng cấp thành float và kết quả là kiểu float. Khi một giá trị kép bị trừ khỏi nó, kiểu kết quả được thăng cấp lên gấp đôi. Kết quả cuối cùng của toàn bộ biểu thức là một kép.

Bây giờ chúng ta đã quen thuộc với tất cả các kiểu đơn giản, bao gồm số nguyên và số thực, ký hiệu và biến boolean, chúng ta hãy thử kết hợp tất cả thông tin lại với nhau. Ví dụ sau đây tạo các biến của mỗi kiểu đơn giản và xuất giá trị của các biến đó.

lớp SimpleTypes (
public static void main (String args) (
byte b = 0x55;
ngắn s = 0x55ff;
int i = 1000000;
dài l = 0xffffffffL;
char với= 'A';
float f = .25f;
đôi d = .00001234;
boolean bool = true;
System.out.println ("byte b =" + b);
System.out.println ("short s =" + s);
System.out.println ("int i =” + i);
System.out.println ("long 1 =" + l);
System.out.println ("char với= ”+ S);
System.out.println ("float f =" + f);
System.out.println ("double d =" + d);
System.out.println ("boolean bool =” + bool);)
}

Bằng cách chạy chương trình này, bạn sẽ nhận được kết quả hiển thị bên dưới:

byte b = 85
quần đùi = 22015
int i = 1000000
dài 1 = 4294967295
char với= a
float f = 0,25
gấp đôi d = 1,234e-005
boolean bool = true

Lưu ý rằng các số nguyên được in dưới dạng ký hiệu thập phân, mặc dù chúng tôi đã chỉ định các giá trị cho một số trong số chúng ở dạng ký hiệu thập lục phân.

Chúng tôi đã kết thúc bài viết cuối cùng của chúng tôi về thực tế là tôi đã hứa sẽ cho bạn biết những loại có thể được cast và tất cả được thực hiện như thế nào. Bắt đầu nào.

Dàn diễn viên v biểu thức số họcđược thực hiện tự động.

byte-> short-> int-> long-> float-> double

Nếu các toán hạng a và b được kết hợp với một toán tử nhị phân (chúng ta sẽ thảo luận điều này bên dưới), trước khi thực thi, cả hai toán hạng đều được chuyển đổi thành dữ liệu cùng kiểu như sau:

Nếu một trong các toán tử thuộc loại double, thì toán tử thứ hai cũng được chuyển thành double;
Nếu một trong các toán tử là float, toán tử kia cũng được chuyển đổi thành float;
Nếu một trong các toán tử dài, toán tử thứ hai cũng được chuyển đổi thành dài;
Nếu một trong các toán tử thuộc kiểu int, thì toán tử thứ hai cũng được chuyển đổi thành int;

Chuyển đổi loại được phép

Các đường liền nét cho thấy quá trình chuyển đổi được thực hiện mà không làm mất thông tin. Việc chuyển đổi này được thực hiện một cách ngầm định. Các chuyển đổi trong đó mất thông tin có thể xảy ra được gọi là truyền. Chúng được hiển thị bằng các đường đứt nét. Nếu không có dòng nào cho kiểu dữ liệu trong hình, thì việc chuyển đổi như vậy là không thể. Việc biến đổi thông tin thất thoát cần phải được thực hiện rất cẩn thận. Vì vậy, làm thế nào bạn có thể mất một phần dữ liệu đáng kể và chương trình có thể hoạt động chính xác.

Đối với việc thu hẹp các lâu đài, nó phải được thực hiện rõ ràng. Ví dụ: byte b = (byte) 128; đã gán int cho kiểu byte.

Tôi đề nghị làm một vài ví dụ.

Bạn có thể đã hiểu lầm mã đã cho vì tôi vẫn chưa giải thích trình biên dịch là gì, hằng số, v.v. Tiếp theo trong hướng dẫn này, tôi sẽ cho bạn biết mọi thứ, mặc dù lẽ ra tôi nên làm điều đó sớm hơn. Và bây giờ tôi muốn mô tả những quy tắc nào mà tên của các biến phải có.

Tên biến không được bắt đầu bằng chữ số và không được dùng trong tên dưới dạng số học và toán tử logic và cả ký hiệu '#'.
Các ký tự '$' hoặc '_' được chấp nhận, bao gồm cả vị trí và tên đầu tiên.
Một biến kiểu nguyên thủy được khai báo là thành viên của một lớp (biến toàn cục) được đặt thành 0 theo mặc định.
Nếu một biến được khai báo là biến cục bộ trong một phương thức, thì nó phải được khởi tạo trước khi sử dụng. Vì các biến cục bộ không được khởi tạo theo mặc định. Điều này có nghĩa là bạn không thể khai báo một biến cục bộ và để nó chưa được khởi tạo. Đó là, như thế này: int i;. Nếu bạn thực hiện điều này trong một phương thức, trình biên dịch sẽ yêu cầu bạn đặt giá trị mặc định, trong khi tạo một biến như một thành viên của một lớp (toàn cục), trình biên dịch sẽ đặt nó thành 0.
Phạm vi và thời gian tồn tại của một biến bị giới hạn bởi khối () mà nó được khai báo. Nếu bạn đã tạo một biến bên trong phương thức (như chúng ta đã làm trong các ví dụ), thì bạn không thể sử dụng nó bên ngoài phương thức, vì phương thức được phân tách bằng dấu ngoặc đơn (). Biến toàn cục có thể nhìn thấy trong tất cả các khối.
Nó cũng bị cấm sử dụng các từ dành riêng cho java. Toàn bộ danh sách từ khóa có thể được nhìn thấy trong hình dưới đây.

Và vì vậy, như trong bài viết này, tôi đã đề cập đến biểu thức toán tử nhị phân, sau đó tôi đề xuất xem xét các toán tử trong Java. Hơn nữa, không có quá nhiều lý thuyết.

Java có một số loại toán tử: phép gán đơn giản, số học, một ngôi, ngang hàng và quan hệ, có điều kiện, so sánh kiểu, bitwise và bù bit.

Có rất nhiều từ thông minh, nhưng bức tranh này sẽ giải thích mọi thứ rất đơn giản:

Lúc đầu, chúng tôi sẽ sử dụng so sánh bitwise, gán và toán tử postfix... Các toán tử khác không quá phổ biến, vì vậy chúng tôi sẽ chỉ xem xét những toán tử mà chúng tôi sẽ sử dụng.

lớp công khai OperatorInJava (

int a = 5;

int b = 6;

int sum = a + b;

int chênh lệch = a - b;

Cập nhật lần cuối: 29/10/2018

Mỗi loại cơ sở dữ liệu mất một số tiền nhất định của byte bộ nhớ. Điều này đặt ra một hạn chế đối với các hoạt động trong đó các loại khác nhau dữ liệu. Hãy xem xét ví dụ sau:

Int a = 4; byte b = a; //! Lỗi

Trong đoạn mã này, chúng ta sẽ gặp một lỗi. Mặc dù cả byte và int đều đại diện cho số nguyên. Hơn nữa, giá trị của biến a, được gán cho một biến kiểu byte, nằm trong phạm vi giá trị của kiểu byte (từ -128 đến 127). Tuy nhiên, chúng tôi gặp phải lỗi thời gian biên dịch. Kể từ trong trong trường hợp này chúng tôi đang cố gắng gán một số dữ liệu có 4 byte cho một biến chỉ có 1 byte.

Tuy nhiên, chương trình của bạn có thể cần thực hiện chuyển đổi này. Trong trường hợp này, tôi cần sử dụng thao tác chuyển đổi kiểu (thao tác ()):

Int a = 4; byte b = (byte) a; // chuyển kiểu: từ int sang byte System.out.println (b); // 4

Thao tác chuyển đổi kiểu ngụ ý một chỉ báo trong ngoặc đơn của kiểu mà giá trị sẽ được chuyển đổi. Ví dụ, trong trường hợp của (byte) một phép toán, kiểu dữ liệu int đang được chuyển đổi thành kiểu byte. Kết quả là, chúng tôi nhận được một giá trị byte.

Chuyển đổi rõ ràng và ngầm hiểu

Khi dữ liệu tham gia vào một hoạt động các loại khác nhau, không phải lúc nào cũng cần sử dụng thao tác chuyển đổi kiểu. Một số loại chuyển đổi được thực hiện ngầm, tự động.

Chuyển đổi tự động

Các mũi tên trong hình cho biết loại chuyển đổi nào có thể được thực hiện tự động. Các mũi tên chấm hiển thị các chuyển đổi tự động không chính xác.

Được sản xuất tự động mà không gặp bất kỳ vấn đề gì mở rộng biến đổi(mở rộng) - chúng mở rộng biểu diễn của một đối tượng trong bộ nhớ. Ví dụ:

Byte b = 7; int d = b; // chuyển đổi từ byte sang int

Trong trường hợp này, một byte, chiếm 1 byte trong bộ nhớ, được mở rộng thành int, chiếm 4 byte.

Mở rộng chuyển đổi tự độngđược đại diện bởi các chuỗi sau:

byte -> ngắn -> int -> dài

int -> gấp đôi

short -> float -> double

char -> int

Chuyển đổi tự động không chính xác

Một số chuyển đổi có thể được thực hiện tự động giữa các loại dữ liệu có cùng độ sâu bit, hoặc thậm chí từ loại dữ liệu có độ sâu bit cao hơn sang loại có độ sâu bit thấp hơn. Đây là các chuỗi chuyển đổi sau: int -> float, long -> float và long -> double được thực hiện mà không có lỗi, nhưng chúng tôi có thể gặp phải tình trạng mất thông tin trong quá trình chuyển đổi.

Ví dụ:

Int a = 2147483647; float b = a; // từ int sang float System.out.println (b); // 2.14748365E9

Chuyển đổi rõ ràng

Trong tất cả các phép biến đổi khác các loại nguyên thủyđịnh nghĩa chuyển đổi kiểu được áp dụng rõ ràng. Thông thường, đây là các chuyển đổi thu hẹp từ loại có độ sâu bit cao hơn sang loại có độ sâu bit thấp hơn:

Dài a = 4; int b = (int) a;

Mất dữ liệu trong quá trình chuyển đổi

Khi sử dụng các phép biến đổi rõ ràng, chúng tôi có thể bị mất dữ liệu. Ví dụ: với đoạn mã sau, chúng tôi sẽ không gặp bất kỳ sự cố nào:

Int a = 5; byte b = (byte) a; System.out.println (b); // 5

Số 5 rất phù hợp với phạm vi giá trị của kiểu byte, vì vậy sau khi chuyển đổi, biến b sẽ là 5. Nhưng điều gì sẽ xảy ra trong trường hợp sau:

Int a = 258; byte b = (byte) a; System.out.println (b); // 2

Kết quả là 2. Trong trường hợp này, 258 nằm ngoài phạm vi cho byte (-128 đến 127), vì vậy giá trị sẽ bị cắt bớt. Tại sao kết quả lại chính xác là số 2?

Số a, là 258, trong hệ thống nhị phân sẽ bằng 00000000 00000000 00000001 00000010. Giá trị byte chỉ chiếm 8 bit trong bộ nhớ. Cho nên biểu diễn nhị phân int được cắt bớt 8 chữ số bên phải, đó là 00000010, là hệ thống thập phânđưa ra số 2.

Cắt ngắn số hữu tỉ thành số nguyên

Khi chuyển đổi giá trị dấu phẩy động thành giá trị nguyên, phần phân số bị cắt bớt:

Nhân đôi a = 56,9898; int b = (int) a;

Ở đây b sẽ là 56, mặc dù 57 sẽ gần hơn với 56,9898. Để tránh những sự cố như vậy, bạn cần sử dụng hàm làm tròn, nằm trong thư viện toán học Java:

Nhân đôi a = 56,9898; int b = (int) Math.round (a);

Chuyển đổi trong hoạt động

Thường có những tình huống bạn phải nộp đơn các hoạt động khác nhau, ví dụ, bổ sung và sản phẩm, trên các giá trị của các loại khác nhau. Một số quy tắc cũng được áp dụng ở đây:

nếu một trong các toán hạng của phép toán đề cập đến gõ đôi, sau đó toán hạng thứ hai cũng được chuyển đổi thành kiểu kép

nếu điều kiện trước đó không được đáp ứng và một trong các toán hạng của phép toán thuộc kiểu float, thì toán hạng thứ hai cũng được chuyển đổi thành kiểu float

nếu như điều kiện trước đó không được đáp ứng, một trong các toán hạng của hoạt động đề cập đến loại dài, sau đó toán hạng thứ hai cũng được chuyển đổi thành kiểu long

nếu không, tất cả các toán hạng của hoạt động được chuyển đổi thành kiểu int

Ví dụ về các phép biến đổi:

Int a = 3; nhân đôi b = 4,6; nhân đôi c = a + b;

Vì thao tác liên quan đến giá trị kép, nên giá trị khác được chuyển thành kiểu kép và tổng của hai giá trị a + b sẽ đại diện cho kiểu kép.

Một vi dụ khac:

Byte a = 3; ngắn b = 4; byte c = (byte) (a + b);

Hai biến có kiểu byte và short (không phải double, float hoặc long), vì vậy chúng được chuyển đổi thành int khi được thêm vào và tổng a + b của chúng đại diện cho một int. Do đó, nếu sau đó chúng ta gán tổng này cho một biến kiểu byte, thì chúng ta lại cần thực hiện chuyển đổi kiểu thành byte.

Nếu các phép toán liên quan đến dữ liệu kiểu char, thì chúng được chuyển đổi thành int:

Int d = "a" + 5; System.out.println (d); // 102

Người nói trước đã mô tả sự chuyển đổi từ trên xuống khá đầy đủ, nhưng từ dưới lên (theo ý kiến của tôi) cần phải giải thích thêm, vì câu hỏi rất phổ biến và thú vị.

Cách hoạt động của tính năng truyền rõ ràng

Ví dụ của bạn cho thấy một chuyển đổi tăng lên ( Dự báo):

Danh sách coll = new ArrayList ();

Nó dịch sang tiếng Nga như sau: tạo ra một con quạ, chẳng hạn như một con chim. Tạo ra mảng động, loại trang tính. Trong hầu hết các tình huống, chuyển đổi lên là hoàn toàn không cần thiết.
Tuy nhiên, việc casting hoạt động trong các cuộc phỏng vấn khi bạn được hỏi những câu hỏi về quyền thừa kế. Ví dụ, trang quizful.net thường chứa nhiều câu hỏi về việc đánh máy. Do đó, tôi sẽ giải thích các tính năng mà tôi biết.

Vì vậy, trong ví dụ trên, chúng ta đã tạo một đối tượng kiểu ArrayList và một tham chiếu kiểu List. Hãy nhớ các tiên đề cho phương pháp này:

1. Liên kết có thể trỏ đến bất kỳ phụ huynh nào. Ngay cả một thời gian rất dài trước đây. Đó là, bạn có thể ép kiểu coll ngay cả khi nhập Object. Trình biên dịch sẽ bỏ qua bất kỳ tham chiếu nào đến lớp cha, hoặc cha-mẹ, hoặc cha-mẹ ... cha

2. Tham chiếu đến trường - trường tham chiếu luôn được trả về, không phải trường đối tượng. Nếu không có trường này trong lớp tham chiếu, sẽ có lỗi biên dịch.

Lớp A (int x = 2; // Trường cha) Lớp B mở rộng A (int x = 3; // Trường phải chồng lên lớp cha int y = 5; // Trường không có trong lớp cha.) Kiểm tra lớp (public static void main (String args) (A ab = new B (); // Chuyển đổi trở lên System.out.println ("Int x =" + ab.x);))

Sẽ trở lại Int x = 2 ... Nếu bạn cố gắng truy cập một trường đối tượng:

System.out.println ("Int y =" + ab.y); // Dịch lỗi

Trình biên dịch của bạn sẽ nói rằng bạn đã sai, vì nó không nhìn thấy một trường như vậy bằng tham chiếu (A ab). Tất cả những điều trên vẫn hợp lệ ngay cả khi các trường của bạn được đánh dấu bằng các công cụ sửa đổi tĩnh.

3. Gọi một phương thức không tĩnh: trong trường hợp này, nó sẽ trả về phương thức của đối tượng. Nhưng khi truy cập một phương thức tĩnh, nó sẽ trả về phương thức tham chiếu.

Lớp D (public void doSome () (// Not phương pháp tĩnh System.out.println ("Không có chủ đề doSome từ D"); ) public static void Action () (// Static method System.out.println ("static Action from D");)) public class Okey mở rộng D (public void doSome () (System.out.println ("doSome from Okey ");) public static void Action () (System.out.println (" static Action from Okey ");) public static void main (String args) (D o = new Okey (); o.doSome (); / / Từ lớp Okey o.Action (); // Từ lớp D))

Nonstatic doSome from Okey

hành động tĩnh từ D

Câu trả lời rất đơn giản, một phương thức non-static là một phương thức đối tượng, một phương thức static là một phương thức lớp. Khi chúng ta gọi một phương thức không tĩnh, trình biên dịch hiểu điều này: bay như một con quạ. Khi chúng ta gọi là tĩnh - theo nghĩa đen, bay như một con chim.

4. Nếu có một lệnh gọi đến một phương thức được mô tả trong lớp đối tượng, nhưng không được mô tả trong lớp tham chiếu, lỗi biên dịch sẽ xảy ra. Bởi vì, phương thức được gọi bằng tham chiếu:

Lớp A () Lớp B mở rộng A (void someMethod () (); public static void main (String args) (A ab = new B (); ab.someMethod (); // Lỗi biên dịch.))

5. Hàm tạo của một đối tượng (khi được tạo bằng lệnh mới) hoạt động giống như khi bạn cung cấp một tham chiếu cho lớp của mình.