วิธีต่างๆ ในการสร้างวัตถุใน Java
ที่มา:
สื่อ ในบทช่วยสอนนี้ เราจะเรียนรู้วิธีต่างๆ ในการสร้างวัตถุใน Java ![คอฟฟี่เบรค #174. วิธีต่างๆ ในการสร้างวัตถุใน Java.String เป็น Int ใน Java - วิธีแปลงสตริงเป็นจำนวนเต็ม - 1]()
วัตถุ Java เป็นอินสแตนซ์ของคลาส Java แต่ละอ็อบเจ็กต์มีสถานะ พฤติกรรม และตัวระบุ ช่อง (ตัวแปร) จะจัดเก็บสถานะของออบเจ็กต์ ในขณะที่เมธอด (ฟังก์ชัน) จะแสดงการทำงานของออบเจ็กต์ คลาสทำหน้าที่เป็น “พิมพ์เขียว” ที่ใช้สร้างอินสแตนซ์ออบเจ็กต์ขณะรันไทม์
การสร้างวัตถุใน Java
การสร้างวัตถุเป็นกระบวนการจัดสรรหน่วยความจำเพื่อจัดเก็บข้อมูลในฟิลด์คลาส (หรือที่เรียกว่าตัวแปร) กระบวนการนี้มักเรียกว่าการสร้างอินสแตนซ์ของคลาส มีสี่วิธีที่แตกต่างกันในการสร้างวัตถุใน Java:
- โดยใช้ คำสำคัญ ใหม่
- วิธีการnewInstance()
- วิธีการโคลน ()
- การดีซีเรียลไลซ์วัตถุ
ตอนนี้เรามาดูรายละเอียดแต่ละวิธีที่กล่าวถึงกัน
คำหลักใหม่
นี่เป็นวิธีทั่วไปในการสร้างวัตถุใน Java คำหลัก
ใหม่สร้างอินสแตนซ์ของคลาสโดยการจัดสรรหน่วยความจำสำหรับอินสแตนซ์ใหม่ของประเภทที่ระบุ หลังจากที่ใหม่มาถึงตัวสร้าง - วิธีการพิเศษที่รับผิดชอบในการสร้างวัตถุและการเริ่มต้นฟิลด์ของวัตถุที่สร้างขึ้น วัตถุถูกสร้างขึ้นด้วย ตัวดำเนินการ
ใหม่และเริ่มต้นด้วยตัวสร้าง นี่คือตัวอย่างของการสร้างวัตถุ Java ด้วย ตัวดำเนินการ
ใหม่ :
Date today = new Date();
นิพจน์นี้สร้าง วัตถุ
Date ใหม่ (
Dateเป็นคลาสภายใน แพ็คเกจ
java.util ) ส่วนคำสั่งเดียวในโค้ดนี้ดำเนินการสามอย่าง: การประกาศ การสร้างอินสแตนซ์ และการเริ่มต้น
Date todayคือการประกาศตัวแปรที่แจ้งให้คอมไพลเลอร์ทราบว่าtoday
จะอ้างถึงอ็อบเจ็กต์ประเภท
Date ตัวดำเนินการใหม่จะสร้างอินสแตนซ์ คลาส
Date (สร้าง วัตถุ
Date ใหม่ ในหน่วยความจำ) และ
Date()เตรียมใช้งานวัตถุ ลองพิจารณาตัวอย่างด้านล่าง:
public class Person {
private String name;
private int uid;
public Person() {
this.name = "Michael Cole";
this.uid = 101;
}
public Person(String name, int uid) {
super();
this.name = name;
this.uid = uid;
}
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person("John Bodgan", 102);
System.out.println("Name: " + p1.getName() + " UID: " + p1.getUid());
System.out.println("Name: " + p2.getName() + " UID: " + p2.getUid());
}
}
จากโค้ดนี้ เราสร้าง อ็อบเจ็กต์
Person โดยใช้ คีย์เวิร์ด
ใหม่ :
- วัตถุp1เรียกตัวสร้างที่ไม่มีพารามิเตอร์โดยตั้งค่าชื่อตัวแปรเป็น "Michael Cole" และ UID ตั้งค่าเป็น 101
- วัตถุp2เรียกตัวสร้างพารามิเตอร์โดยที่ส่งค่า "John Bodgan" และ 102 ไปยังตัวสร้าง จากนั้น ค่าเหล่านี้จะถูกกำหนดชื่อตัวแปรและ UID
ใช้เมธอด newInstance()
newInstance()วิธีการใน Java ใช้เพื่อสร้างอินสแตนซ์ของวัตถุของคลาสที่กำหนดแบบไดนามิก มีการใช้ เมธอด
newInstance() มาตรฐานสองแบบ :
- newInstance()วิธีการจากjava.lang.Class API
- newInstance()วิธีการจากjava.lang.reflect.Constructor API
การใช้ newInstance() จาก Class API
ในการสร้างวัตถุของคลาสในขณะรันไทม์ เราต้องเรียก เมธอด
newInstance()จาก Class API ซึ่งจะส่งคืนวัตถุของคลาสนั้น เมธอด
newInstance() ของ คลาส
java.lang.Classไม่ใช้พารามิเตอร์หรืออาร์กิวเมนต์ใดๆ และสามารถเรียกได้ว่าเป็นคอนสตรัคเตอร์ที่ไม่มีอาร์กิวเมนต์สำหรับคลาสนั้น มาดูโค้ดตัวอย่างเพื่อสร้างอ็อบเจ็กต์ของ คลาส
Personโดยใช้ เมธอด
newInstance() ของ คลาส
java.lang.Class :
public class Person {
private String name;
private int uid;
public Person() {
this.name = "Carl Max";
this.uid = 101;
}
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class c = Class.forName("com.medium.option2.Person");
@SuppressWarnings("deprecation")
Person p = (Person) c.newInstance();
System.out.println("Name: " + p.getName());
System.out.println("UID: " + p.getUid());
}
}
Class.forName (ชื่อแบบเต็มของคลาส) โหลดคลาสชื่อ
Personจากนั้น
newInstance()จะสร้างอ็อบเจ็กต์ใหม่ประเภท
Personและส่งคืนการอ้างอิงถึงคลาสนั้น ตอนนี้ เมื่อใช้ การอ้างอิง
บุคคลถึง
pเราสามารถเรียก
getters()และ
setter()เพื่อดำเนินการบางอย่างได้ โปรดทราบ:
- ทั้งClass.forName()และnewIstance() มีข้อ ยกเว้นที่ต้องจัดการโดยใช้try and catch block หรือ คีย์เวิร์ดThrows
- เมธอดnewInstance()จาก Class API เลิกใช้แล้วตั้งแต่ Java 9
ใช้ newInstance() จาก Constructor API
เมธอด
newInstance() ของ คลาส
Constructor (
java.lang.reflect.Constructor ) คล้ายกับ เมธอด
newInstance() ของ คลาส Class ยกเว้นว่าจะยอมรับพารามิเตอร์สำหรับคอนสตรัคเตอร์ที่มีการกำหนดพารามิเตอร์ มาสาธิตวิธีการนี้โดยการสร้างอ็อบเจ็กต์ของ คลาส
Personโดยใช้ เมธอด
newInstance() ของ คลาส
java.lang.reflect.Constructor :
public class PersonTwo {
private String name;
private int uid;
public PersonTwo() {
this.name = "Maya Kumari";
this.uid = 101;
}
public PersonTwo(String name) {
this.name = name;
this.uid = 102;
}
public PersonTwo(String name, Integer uid) {
this.name = name;
this.uid = uid;
}
public static void main(String[] args) {
try {
Class.forName("com.medium.option2.PersonTwo");
Constructor c1 = PersonTwo.class.getConstructor();
PersonTwo p1 = (PersonTwo) c1.newInstance();
System.out.println("Name: " + p1.getName());
System.out.println("UID: " + p1.getUid());
Constructor c2 = PersonTwo.class.getConstructor(String.class);
PersonTwo p2 = (PersonTwo) c2.newInstance("James Gunn");
System.out.println("Name: " + p2.getName());
System.out.println("UID: " + p2.getUid());
Constructor c3 = PersonTwo.class.getConstructor(String.class, Integer.class);
PersonTwo p3 = (PersonTwo) c3.newInstance("Mark Brown", 103);
System.out.println("Name: " + p3.getName());
System.out.println("UID: " + p3.getUid());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
ในโค้ดข้าง ต้น ขั้นแรกเราต้องโหลดคลาสโดยใช้ เมธอด
Class.forName() ต่อไป เราจะเรียก เมธอด
getConstructor()เพื่อจับคู่ประเภทข้อมูลของพารามิเตอร์ที่ส่งผ่าน สุดท้ายนี้ ใน เมธอด
newInstance()เราจะส่งผ่านพารามิเตอร์ที่ต้องการ (
nullหากไม่มีอาร์กิวเมนต์) เมธอด
newInstance()จะส่งคืนอ็อบเจ็กต์ใหม่ของ คลาส
PersonTwoโดยการเรียกตัวสร้างที่เหมาะสม
ใช้วิธีโคลน ()
วิธีการ
clone()เป็นส่วนหนึ่งของ คลาส
Objectและใช้เพื่อสร้างสำเนาของวัตถุที่มีอยู่ มันสร้างวัตถุของคลาสโดยไม่ต้องเรียกตัวสร้างคลาสใด ๆ ในการโคลนเมธอด คลาสที่เกี่ยวข้องจะต้องใช้งาน อินเทอร์เฟซ
Cloneableซึ่งเป็นอินเทอร์เฟซมาร์กเกอร์ ตอนนี้เราจะสร้างอ็อบเจ็กต์ของ คลาส
Personจากนั้นทำการโคลนมันไปเป็นอ็อบเจ็กต์อื่นของ คลาส
Person :
public class Person implements Cloneable {
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
private String name;
private int uid;
public Person(String name, int uid) {
super();
this.name = name;
this.uid = uid;
}
public static void main(String[] args) {
Person p1 = new Person("Ryan", 101);
try {
Person p2 = (Person) p1.clone();
System.out.println("Name: " + p2.getName());
System.out.println("UID: " + p2.getUid());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
บันทึก. วัตถุที่โคลนจะอ้างอิงวัตถุต้นฉบับเดียวกันผ่านการอ้างอิง
p2 อย่างไรก็ตาม วัตถุที่ถูกโคลนจะมีการกำหนดหน่วยความจำแยกต่างหาก ซึ่งหมายความว่าการเปลี่ยนแปลงใด ๆ ที่ทำกับ วัตถุ
Personที่อ้างอิงโดย
p2จะไม่เปลี่ยนวัตถุ Person ดั้งเดิมที่
อ้างอิงโดย
p1 เนื่องจาก เมธอด
clone()สร้างสำเนาแบบตื้นของวัตถุ
การใช้วัตถุดีซีเรียลไลเซชัน
การดีซีเรียลไลซ์อ็อบเจ็กต์เป็นกระบวนการแยกอ็อบเจ็กต์ออกจากชุดสตรีมไบต์ การทำให้เป็นอนุกรมทำสิ่งที่ตรงกันข้าม วัตถุประสงค์หลักคือการดึงวัตถุที่เก็บไว้จากฐานข้อมูล/เครือข่ายกลับเข้าสู่หน่วยความจำ หากเราต้องการทำให้วัตถุเป็นอนุกรมหรือดีซีเรียลไลซ์ เราจำเป็นต้องใช้อินเท อร์เฟซ
แบบอนุกรม (อินเทอร์เฟซโทเค็น) ลองพิจารณาตัวอย่างด้านล่าง:
public class PersonDriver {
public static void main(String[] args) {
Person p1 = new Person("Max Payne", 101);
FileOutputStream fileOutputStream;
try {
fileOutputStream = new FileOutputStream("link to text file");
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(p1);
outputStream.flush();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
FileInputStream fileInputStream;
try {
fileInputStream = new FileInputStream("link to text file");
ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
Person p2 = (Person) inputStream.readObject();
System.out.println("Name: " + p2.getName());
System.out.println("UID: " + p2.getUid());
inputStream.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
ขั้นแรกเราจะทำให้ อ็อบเจ็กต์
Person เป็นอนุกรม โดยการอ้างอิง
p1ลงในไฟล์ข้อความ เมธอด
writeObject()จะเขียนสตรีมไบต์ของวัตถุไปยังไฟล์ข้อความ จากนั้น เมื่อใช้การดีซีเรียล ไลซ์อ็อบเจ็กต์ เราจะแยก อ็อบเจ็กต์
Personกลับเข้าไปใน
p2 ในทำนองเดียวกัน
readObject() วิธีการ จะอ่านวัตถุจากสตรีมอินพุตของวัตถุ สุดท้าย เราจะพิมพ์ข้อมูลจาก วัตถุ
บุคคลไปยังคอนโซล
บทสรุป
ในบทความนี้ เราได้เรียนรู้เกี่ยวกับวิธีการต่างๆ ในการสร้างอ็อบเจ็กต์ใน Java อันดับแรก เราดูที่การสร้างออบเจ็กต์โดยใช้ คีย์เวิร์ด
ใหม่ซึ่งเป็นวิธีที่ใช้กันทั่วไปมากที่สุด จากนั้นเราได้เรียนรู้ เมธอด
newInstance()จาก
คลาส Classและ
Constructorซึ่งเป็นอีกวิธีหนึ่งยอดนิยมในการสร้างอ็อบเจ็กต์ จากนั้นเราใช้ เมธอด
clone()ซึ่งสร้างสำเนาแบบตื้นของวัตถุที่มีอยู่แทนที่จะสร้างวัตถุใหม่ สุดท้ายนี้ เราใช้แนวคิดเรื่องการทำให้เป็นอนุกรมของวัตถุและดีซีเรียลไลซ์เพื่อสร้างวัตถุใน Java
String เป็น Int ใน Java - วิธีแปลงสตริงเป็นจำนวนเต็ม
ที่มา:
FreeCodeCamp วันนี้คุณจะได้เรียนรู้วิธีการแปลงสตริงเป็นจำนวนเต็มใน Java โดยใช้สองวิธีของคลาสInteger - parseInt()และvalueOf() สิ่งนี้จะช่วยคุณในการดำเนินการทางคณิตศาสตร์โดยใช้ค่าของตัวแปรสตริง
วิธีแปลงสตริงเป็นจำนวนเต็มใน Java โดยใช้ Integer.parseInt
ตัวเลือกนี้จะถือว่า
parseInt() วิธีการ ใช้สตริงในการแปลงเป็นจำนวนเต็มเป็นพารามิเตอร์:
Integer.parseInt(string_varaible)
ก่อนที่จะดูตัวอย่างการใช้งาน เรามาดูว่าจะเกิดอะไรขึ้นเมื่อคุณเพิ่มค่าสตริงและจำนวนเต็มโดยไม่มีการแปลงใดๆ:
class StrToInt {
public static void main(String[] args) {
String age = "10";
System.out.println(age + 20);
}
}
ในโค้ดนี้ เราได้สร้างตัวแปร
อายุด้วยค่าสตริง "10" เมื่อเราบวกเลข 20 เข้ากับค่าจำนวนเต็ม เราได้รับ 1020 ผิดแทนที่จะเป็นคำตอบที่ถูกต้องคือ 30 ซึ่งสามารถแก้ไขได้โดยใช้เมธอด
parseInt() :
class StrToInt {
public static void main(String[] args) {
String age = "10";
int age_to_int = Integer.parseInt(age);
System.out.println(age_to_int + 20);
}
}
ในที่นี้ เพื่อ แปลง ตัวแปรอายุเป็นจำนวนเต็ม เราได้ส่งตัวแปรดังกล่าวเป็นพารามิเตอร์ไปยังเมธอด
parseInt() -
Integer.parseInt(age) - และจัดเก็บไว้ในตัวแปรชื่อ
age_to_int ตอนนี้เมื่อบวกเข้ากับจำนวนเต็มอื่น เรา จะ ได้ค่าบวกที่ถูกต้อง:
age_to_int + 20
วิธีแปลงสตริงเป็นจำนวนเต็มใน Java โดยใช้ Integer.valueOf
เมธอด
valueOf()ทำงานเหมือนกับ เมธอด
parseInt() ใช้เป็นพารามิเตอร์ของสตริงที่ต้องแปลงเป็นจำนวนเต็ม นี่คือตัวอย่าง:
class StrToInt {
public static void main(String[] args) {
String age = "10";
int age_to_int = Integer.valueOf(age);
System.out.println(age_to_int + 20);
}
}
ในโค้ดด้านบน คุณสามารถเห็นสิ่งเดียวกับในส่วนก่อนหน้า:
- เราส่งสตริงเป็นพารามิเตอร์ไปที่valueOf() : Integer.valueOf(age ) มันถูกเก็บไว้ในตัวแปรที่เรียกว่าage_to_int
- จากนั้นเราเพิ่ม 10 ให้กับตัวแปรที่สร้างขึ้น: age_to_int + 20 ผลลัพธ์คือ 30 แทนที่จะเป็น 1,020
บทสรุป
ในบทความนี้ เราได้กล่าวถึงการแปลงสตริงเป็นจำนวนเต็มใน Java ในการแปลงสตริงเป็นจำนวนเต็ม มีการใช้สองวิธีของคลาส
Integer -
parseInt()และ
valueOf() ขอให้มีความสุขในการเขียนโค้ด!
GO TO FULL VERSION