Hướng dẫn java cheat sheet anjali - bảng cheat java anjali

Mục lục

Ngôn ngữ lập trình hướng đối tượng: Dựa trên các khái niệm của các đối tượng trên mạng. Điều này là do mã Java được biên dịch bởi trình biên dịch và được chuyển đổi thành mã byte. Do đó, mã byte độc ​​lập với nền tảng và có thể chạy trên nhiều hệ thống. Yêu cầu duy nhất là Java cần một môi trường thời gian chạy, tức là, JRE, là một bộ công cụ được sử dụng để phát triển các ứng dụng Java. Quản lý thông tin: Ngôn ngữ thu thập rác, tức là, Xử lý bộ nhớ. do đó loại bỏ mọi rủi ro của sự sụp đổ hệ thống. based on the concepts of “objects”.
Open Source: Readily available for development.
Platform-neutral: Java code is independent of any particular hardware or software. This is because Java code is compiled by the compiler and converted into byte code. Thus, byte code is platform-independent and can run on multiple systems. The only requirement is Java needs a runtime environment, i.e., JRE, which is a set of tools used for developing Java applications.
Memory Management: Garbage collected language, i.e., deallocation of memory.
Exception Handling: Catches a series of errors or abnormality, thus eliminating any risk of crashing the system.

Các từ thông dụng Java

Java được mô hình hóa ở dạng cuối cùng, xem xét mục tiêu chính là có các tính năng sau

• Đơn giản, nhỏ và quen thuộc
• Object-Oriented
• Độc lập di động và nền tảng
• Biên soạn và giải thích
• Khả năng mở rộng và hiệu suất
• Mạnh mẽ và an toàn
• Architectural-neutral
• Hiệu suất cao
• Multi-Threaded
• Phân phối
• Năng động và mở rộng

Đọc ở đây: Các tính năng chính của lập trình Java

Các loại dữ liệu nguyên thủy trong Java Java

8 byte

• Loại dữ liệu
• Giá trị mặc định
• Kích thước (tính bằng byte)
• 1 byte = 8 bit
• SAI

1 chút

" " (không gian)

2 byte

• 1 byte
• 4 byte

8 byte

0,0f

, =, ==,! =

Toán tử logic

• &&, ||
• Toán tử chuyển nhượng

=, +=, - =, × =, ÷ =, %=, & =, ^=, | =, =, >>> =

$ javac [file_name].java
$ java [file_name]

Toán tử tăng và giảm: Filename should be the same as the class name containing the main() method, with a .java extension.

++, - -

Toán tử có điều kiện

?:

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

Lưu ý: Tên tệp phải giống như tên lớp chứa phương thức chính (), với phần mở rộng .java.

Ghé thăm ở đây để biết thêm về Java IDE.

Được sử dụng để tạo các đối tượng mới.

tĩnh

Được sử dụng để chỉ ra rằng một biến hoặc một phương thức là một phương thức lớp.
name - The name of the method
parameter list - sequence of type and variables separated by a comma
return - statement to return value to calling routine

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

siêu

Được sử dụng để tham khảo lớp phụ huynh.

đây

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

2. Chuyển đổi

Kiểm tra tình trạng; Nếu một trường hợp cụ thể là đúng, điều khiển được chuyển đến khối đó và được thực thi. Phần còn lại của các trường hợp không được coi là thêm, và chương trình thoát ra khỏi vòng lặp.

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

3. Vòng lặp trong Java

Các vòng lặp được sử dụng để lặp lại mã một số lần cụ thể cho đến khi điều kiện được chỉ định là đúng. Có ba loại vòng lặp trong Java:

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

Trong khi lặp lại

Nếu điều kiện trong một thời gian là đúng, chương trình sẽ nhập vòng lặp để lặp.

Lớp Testwhileloop

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

Làm trong khi vòng lặp

Chương trình nhập vòng lặp để lặp ít nhất một lần bất kể điều kiện trong khi điều kiện là đúng. Đối với các lần lặp hơn nữa, nó phụ thuộc vào điều kiện trong khi là đúng. apple, mango, and orange are members of class fruit.

class TestDoWhileLoop
{
public static void main (String args[])
{
int i = 1;
do
{
System.out.println(i);
i++;
}
while(i<=10);
}
}

Khái niệm Java oops
This insulation of data from direct access by the program is called data hiding. For instance, while using apps, people are concerned about their functionality and not their code.

Một mô hình hướng đối tượng cung cấp các khái niệm sau để đơn giản hóa việc phát triển và bảo trì phần mềm.

1. Đối tượng và lớp học

Đối tượng là các thực thể thời gian chạy cơ bản trong một hệ thống hướng đối tượng, chứa dữ liệu và mã để thao tác dữ liệu. Toàn bộ tập hợp dữ liệu và mã này có thể được thực hiện thành các loại dữ liệu do người dùng xác định bằng các khái niệm lớp. Do đó, một lớp là một tập hợp các đối tượng thuộc loại dữ liệu tương tự.

• Ví dụ: Apple, xoài và cam là thành viên của trái cây.The child class inherits properties and behavior from a single parent class.
• 2. Trừu tượng và đóng gói dữ liệuThe child class inherits properties from its parent class, which in turn is a child class to another parent class.
• Việc bao bọc hoặc kèm theo dữ liệu và phương pháp thành một đơn vị được gọi là đóng gói. Lấy viên nang thuốc làm ví dụ; Chúng tôi không biết nó chứa hóa chất nào; Chúng tôi chỉ quan tâm đến hiệu ứng của nó. Cách điện dữ liệu này từ truy cập trực tiếp của chương trình được gọi là ẩn dữ liệu. Chẳng hạn, trong khi sử dụng các ứng dụng, mọi người quan tâm đến chức năng của họ chứ không phải mã của họ.When a child class has two parent classes. In Java, this concept is achieved by using interfaces.
• 3. Kế thừaWhen a parent class has two child classes inheriting its properties.

class A
{
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
// Create a subclass by extending class A.
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
class SimpleInheritance {
public static void main(String args[]) {
A objA = new A();
B objB = new B();
// The superclass may be used by itself
objA.i = 10;
objA.j = 20;
System.out.println("Contents of objA: ");
objA.showij();
System.out.println();

/* The subclass can access to all public members of
its superclass. */

objB.i = 7;
objB.j = 8;
objB.k = 9;
System.out.println("Contents of objB: ");
objB.showij();
objB.showk();
System.out.println();
System.out.println("Sum of i, j and k in objB:");
objB.sum();
}
}

Kế thừa cung cấp khái niệm về khả năng tái sử dụng; Đó là cách các đối tượng của một lớp (lớp con hoặc lớp con) kế thừa các thuộc tính hoặc rút ra các thuộc tính của các đối tượng của lớp khác (lớp cha).

• Các loại kế thừa trong Java
• Kế thừa duy nhất: Lớp con kế thừa các thuộc tính và hành vi từ một lớp cha mẹ đơn lẻ.
• Di truyền đa cấp: Lớp con kế thừa các thuộc tính từ lớp cha của nó, từ đó là lớp con sang lớp cha khác.

Nhiều kế thừa: Khi một lớp con có hai lớp cha. Trong Java, khái niệm này đạt được bằng cách sử dụng các giao diện.

Di truyền phân cấp: Khi một lớp cha có hai lớp con kế thừa các thuộc tính của nó.

Một số hạn chế trong kế thừa:

Lớp con không thể lấy được các thành viên tư nhân của siêu lớp.

Các lớp con không thể kế thừa các hàm tạo.

Có thể có một siêu lớp cho một lớp con.

class ParentMath
{
void area()
{
int a =2;
System.out.printf("Area of Square with side 2 = %d %n", a * a);
System.out.println();
}
}
class ChildMath extends ParentMath
{
void area()
{
int a =4;
System.out.printf("Area of Square with side 4= %d %n", a * a);
}
public static void main (String args[])
{
ChildMath obj = new ChildMath();
obj.area();
}
}

4. Đa hình

Được định nghĩa là khả năng có nhiều hơn một hình thức. Đa hình cho phép tạo mã sạch và có thể đọc được.

Trong đa hình Java, khái niệm quá tải phương pháp và ghi đè phương pháp đạt được, đó là cách tiếp cận động.

1. 4.1. Phương thức ghi đè

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

1. Trong một hệ thống phân cấp lớp, khi một phương thức trong lớp con có cùng tên và chữ ký loại như một phương thức trong lớp cha của nó, thì phương thức trong lớp con được cho là ghi đè phương thức trong lớp cha.

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

1. Nếu chúng ta không ghi đè lên phương thức trong mã bên dưới, đầu ra sẽ là 4 như được tính toán trong lớp ParentMath; Nếu không, nó sẽ là 16.

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

4.2. Phương pháp quá tải

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

Lập trình Java có thể có hai hoặc nhiều phương thức trong cùng một lớp chia sẻ cùng tên, miễn là các tuyên bố đối số của họ là khác nhau. Các phương pháp như vậy được gọi là quá tải và quá trình được gọi là quá tải phương thức.

Ba cách để quá tải một phương thức:

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

Số lượng tham số

Loại dữ liệu của tham số

• Trình tự của loại dữ liệu của tham số
• Chương trình để giải thích sự thừa kế đa cấp và quá tải phương pháp:
• Lớp học trừu tượng
• Siêu lớp chỉ xác định một hình thức tổng quát được chia sẻ bởi tất cả các lớp con của nó, để lại cho mỗi lớp con để thực hiện các phương thức của nó.
• Giao diện

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

Một giao diện lớp lớp có thể được trừu tượng hóa hoàn toàn từ việc triển khai của nó bằng cách sử dụng từ khóa giao diện trên mạng. Do đó, chúng tương tự như lớp ngoại trừ việc chúng thiếu các biến thể hiện và phương thức của chúng được khai báo mà không có ai.

• Một số lớp có thể thực hiện một giao diện.
• Các giao diện được sử dụng để thực hiện nhiều kế thừa.
• Các biến là công khai, cuối cùng và tĩnh.
• Các hàm tạo không thể là tĩnh, trừu tượng hoặc cuối cùng.

Người xây dựng có thể là:

• Hàm tạo không tham số hoặc mặc định: Được gọi tự động ngay cả khi không được khai báo.

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

• Tham số hóa: Được sử dụng để khởi tạo các trường của lớp với các giá trị được xác định trước từ người dùng.

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

Tìm hiểu thêm về hàm tạo Java.Java Constructor.

Mảng trong Java

Một mảng là một nhóm các biến loại giống như được gọi bởi một tên chung, có bộ nhớ liên tục. Các đối tượng giá trị nguyên thủy được lưu trữ trong một mảng. Nó cung cấp tối ưu hóa mã vì chúng tôi có thể sắp xếp dữ liệu hiệu quả và cũng truy cập ngẫu nhiên. Lỗ hổng duy nhất là chúng ta có thể có một phần tử có kích thước cố định trong một mảng.

Có hai loại mảng được xác định trong Java:

• Kích thước đơn: Các phần tử được lưu trữ trong một hàng

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

{
public static void main (String args[])
{
int i = 1;
while(i<=10)
{
System.out.println(i);
i++;
}
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestForLoop
{
public static void main (String args[])
{
for(int i=0;i<=5;i++)
System.out.println("*");
}
}

class TestDoWhileLoop
{
public static void main (String args[])
{
int i = 1;
do
{
System.out.println(i);
i++;
}
while(i<=10);
}
}

• Đa chiều: Các phần tử được lưu trữ dưới dạng hàng và cột

Lớp Matrixarray

{

Công khai tĩnh void chính (String args [])

{

Công khai tĩnh void chính (String args [])

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

int [] [] m2 = {{2,2,2}, {1,1,1}, {2,1,2}};

int [] [] sum = new int [3] [3];

// in ma trận

System.out.println ("Các ma trận đã cho là:");

{

Công khai tĩnh void chính (String args [])

{

Công khai tĩnh void chính (String args [])

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

System.out.println();

int [] [] m2 = {{2,2,2}, {1,1,1}, {2,1,2}};

System.out.println();

System.out.println ("Các ma trận đã cho là:");

{

Công khai tĩnh void chính (String args [])

{

Công khai tĩnh void chính (String args [])

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

System.out.println();

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

int [] [] m2 = {{2,2,2}, {1,1,1}, {2,1,2}};

int [] [] sum = new int [3] [3];

System.out.println ("Các ma trận đã cho là:");

{

Công khai tĩnh void chính (String args [])

{

Công khai tĩnh void chính (String args [])

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

System.out.println();

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

int [] [] m1 = {{1,2,1}, {2,1,1}, {1,1,2}};

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

int [] [] m2 = {{2,2,2}, {1,1,1}, {2,1,2}};

int [] [] sum = new int [3] [3];

• // in ma trận
• System.out.println ("Các ma trận đã cho là:");
• for (int a = 0; a
• for (int b = 0; b

System.out.print (m1 [a] [b] + "");

System.out.println ("Tổng của 2 ma trận đã cho là:");

sum [a] [b] = m1 [a] [b] + m2 [a] [b];

class TestVariables
{
int data = 20; // instance variable
static int number = 10; //static variable
void someMethod()
{
int num = 30; //local variable
}
}

Concat ()

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Concatenates hai chuỗi

• Subring (n)
• trả về nhà phụ trở lại từ ký tự n
• Subring (N, M)

Trả về một chuỗi con giữa ký tự N và MA.

• toString ()
• tạo biểu diễn chuỗi của đối tượng

indexof (‘x,)

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Trả về vị trí của lần xuất hiện đầu tiên của x trong chuỗi.

Đối với các chuỗi có thể thay đổi, chúng ta có thể sử dụng các lớp StringBuilder và StringBuffer, cũng như triển khai giao diện CharSequence.

Các lớp này đại diện cho giao diện nhân vật có thể phát triển và có thể ghi.Process of executing multiple tasks simultaneously to utilize the CPU.

Họ tự động phát triển để nhường chỗ cho việc bổ sung và thường có nhiều nhân vật được phân bổ trước hơn thực sự cần thiết để cho phép có chỗ cho sự phát triển.

1. 1. • Chênh lệch giữa chiều dài () và công suất ()
      • Chiều dài (): Để tìm độ dài của StringBuffer

Công suất (): Để tìm tổng công suất được phân bổ

Vòng đời của chủ đề

Một chủ đề luôn ở một trong năm trạng thái sau đây; Nó có thể di chuyển từ trạng thái này sang trạng thái khác theo nhiều cách khác nhau, như được hiển thị.

• Chủ đề mới: Đối tượng luồng được tạo. Hoặc nó có thể được lên lịch để chạy bằng phương thức start (). Thread object is created. Either it can be scheduled for running using the start() method.
• Runnable Chủ đề: & nbsp; Chủ đề đã sẵn sàng để thực thi và chờ bộ xử lý. The thread is ready for execution and waiting for the processor.
• Chạy chủ đề: Nó đã có bộ xử lý để thực thi.It has got the processor for execution.
• Chủ đề bị chặn: Chủ đề được ngăn không cho vào trạng thái có thể chạy được. Thread is prevented from entering into a runnable state.
• Trạng thái chết: Chạy chủ đề kết thúc cuộc sống của nó khi nó đã hoàn thành việc thực hiện phương thức chạy () của nó.Running thread ends its life when it has completed executing its run() method.
• Tạo chủ đề
• Mở rộng lớp chủ đề
• Thực hiện giao diện Runnable

Các phương pháp phổ biến của lớp chủ đề

Chương trình để tạo chủ đề bằng lớp chủ đề.

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Thực hiện giao diện Runnable

Phương thức Run () được khai báo trong giao diện Runnable là cần thiết để thực hiện các luồng trong các chương trình của chúng tôi.

Quá trình bao gồm các bước sau:

1. 1. • Tuyên bố lớp thực hiện giao diện Runnable
      • Thực hiện phương thức Run ()
      • Tạo một luồng bằng cách xác định một đối tượng được khởi tạo từ lớp Run Runnable này là mục tiêu của luồng.
      • Gọi phương thức start spart () để chạy luồng.

Sử dụng giao diện Runnable

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Lớp học so với giao diện Runnable

Xử lý ngoại lệ trong Java

Ngoại lệ là một điều kiện bất thường hoặc lỗi do lỗi thời gian chạy trong chương trình; Nếu đối tượng ngoại lệ này bị ném bởi điều kiện lỗi không bị bắt và xử lý đúng cách, trình thông dịch sẽ hiển thị thông báo lỗi. Nếu chúng ta muốn tránh điều này và muốn chương trình tiếp tục, chúng ta nên cố gắng nắm bắt các ngoại lệ. Nhiệm vụ này được gọi là xử lý ngoại lệ.

Ngoại lệ Java phổ biến

Các trường hợp ngoại lệ trong Java có thể là hai loại:

• Đã kiểm tra ngoại lệ

1. • Xử lý rõ ràng trong chính mã với sự trợ giúp của Block-Catch Block.
   • Mở rộng từ Java. Lang.Exception Class

• Ngoại lệ không được kiểm soát

1. • Về cơ bản không được xử lý trong mã chương trình; Thay vào đó, JVM xử lý các ngoại lệ như vậy.
   • Mở rộng từ lớp java.lang.runtimeException

Hãy thử và bắt

Từ khóa thử được sử dụng để mở đầu một khối mã có khả năng gây ra tình trạng lỗi và ném ném ra một ngoại lệ. Từ khóa bắt được xác định một khối bắt bắt bắt được ngoại lệ, ngoại lệ, ném bởi khối thử và xử lý nó một cách thích hợp.

Một mã có thể có nhiều hơn một câu lệnh bắt trong khối bắt; Khi một ngoại lệ trong khối thử được tạo, nhiều câu lệnh bắt được xử lý như các trường hợp trong một câu lệnh chuyển đổi.

Sử dụng thử và bắt để xử lý ngoại lệ

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Cuối cùng

Cuối cùng, tuyên bố: Được sử dụng để xử lý các ngoại lệ không bị bắt bởi bất kỳ câu lệnh bắt nào trước đó. Một khối cuối cùng được đảm bảo để thực thi, bất kể có phải một ngoại lệ có bị ném hay không.used to handle exceptions that are not caught by any previous catch statements. A final block is guaranteed to execute, regardless of whether or not an exception is thrown.

Chúng tôi có thể chỉnh sửa chương trình trên và thêm khối cuối cùng sau.

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Ném ngoại lệ của riêng bạn

Ngoại lệ của riêng có thể được xác định bằng cách sử dụng từ khóa ném.

Ném lớp con ném mới;

/ * Ném ngoại lệ của riêng chúng tôi */

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Quản lý các tệp trong Java

Lưu trữ dữ liệu theo các biến và mảng đặt ra các vấn đề sau:

• Lưu trữ tạm thời: Dữ liệu bị mất khi biến đi ra khỏi phạm vi hoặc khi chương trình bị chấm dứt. The data is lost when the variable goes out of scope or when the program is terminated.
• Dữ liệu lớn: Thật khó khăn. It is difficult.

Các vấn đề như vậy có thể được giải quyết bằng cách lưu trữ dữ liệu trên các thiết bị thứ cấp bằng cách sử dụng khái niệm tệp.

Bộ sưu tập các hồ sơ liên quan được lưu trữ trong một khu vực cụ thể trên đĩa được gọi là tệp. Các tập tin lưu trữ và quản lý dữ liệu theo khái niệm xử lý tệp.

Xử lý tệp bao gồm:

• Tạo tập tin
• Cập nhật tập tin
• Thao tác dữ liệu

Java cung cấp nhiều tính năng trong quản lý tệp như:

• Đọc/Viết dữ liệu có thể được thực hiện ở cấp độ byte hoặc ký tự hoặc trường tùy thuộc vào yêu cầu.
• Nó cũng cung cấp khả năng đọc/ghi trực tiếp các đối tượng.

Dòng suối

Java sử dụng khái niệm các luồng để thể hiện một chuỗi dữ liệu được đặt hàng, một đường dẫn dọc theo luồng dữ liệu. Vì vậy, nó có một nguồn và một điểm đến.

Các luồng được phân loại thành hai loại cơ bản:

• Luồng đầu vào: Trích xuất, tức là, đọc dữ liệu từ tệp nguồn và gửi nó đến chương trình.extracts, i.e., reads data from the source file and sends it to the program.
• Luồng đầu ra: Lấy dữ liệu từ chương trình và gửi, tức là, ghi đến đích. which takes the data from the program and sends, i.e., writes to the destination.

Lớp phát trực tuyến

Chúng được chứa trong gói java.lang.io.

Chúng được phân loại thành hai nhóm.

• Các lớp luồng byte: Cung cấp hỗ trợ để xử lý hoạt động I/O trên byte. provides support for handling I/O operation on bytes.
• Các lớp luồng ký tự: Cung cấp hỗ trợ để quản lý các hoạt động I/O trên các ký tự.provides support for managing I/O operations on characters.

Các lớp dòng byte

Được thiết kế để cung cấp chức năng để tạo và thao tác các luồng và tệp để đọc/ghi byte.

Vì các luồng là đơn hướng, nên có hai loại dòng luồng byte:

• Các lớp luồng đầu vào
• Các lớp dòng đầu ra

Các lớp luồng đầu vào

Các lớp dòng đầu ra

Các lớp dòng đầu ra

Chúng được sử dụng để đọc các byte 8 bit bao gồm một siêu lớp được gọi là InputStream. InputStream là một lớp trừu tượng và xác định các phương thức cho các hàm đầu vào như:

Bỏ qua n byte từ luồng đầu vào

cài lại ( )

Quay trở lại đầu dòng

gần ( )

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

Đóng luồng đầu vào

Các lớp này có nguồn gốc từ đầu ra lớp cơ sở. OutputStream là một lớp trừu tượng và xác định các phương thức cho các hàm đầu ra như:

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

viết( )

Ghi một byte vào luồng đầu ra

Viết (byte B [])

• Ghi tất cả các byte trong mảng B vào luồng đầu ra
• Viết (byte b [], int n, int m)
• Viết m byte từ mảng B bắt đầu từ byte thứ n

gần( )

• Đóng luồng đầu ra
• Flush ()
• Xóa luồng đầu ra

Đọc/Viết byte

Hai lớp con phổ biến được sử dụng là FileInputStream và FileOutputStream xử lý các byte 8 bit.

FileOutputStream được sử dụng để ghi byte vào một tệp như được trình bày dưới đây:

type name (parameter list)
{
//body of the method
//return value (only if type is not void)
}

// viết byte vào một tệp

FileInTputStream được sử dụng để đọc byte từ một tệp, như được trình bày dưới đây:

// đọc byte từ một tệp

Các lớp dòng nhân vật

Hai loại lớp luồng ký tự:

Các lớp học

Các lớp có sẵn trong khung thu thập thực hiện giao diện thu thập và giao diện phụ. Họ cũng thực hiện giao diện MAP và ITERATOR.

Các lớp và giao diện tương ứng của chúng được liệt kê:

bộ sưu tập các yếu tố độc đáo

Sắp xếp (mở rộng bộ)

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

bộ sưu tập các yếu tố độc đáo

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Bản đồ

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

bộ sưu tập các cặp khóa và giá trị, phải là duy nhất

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Sắp xếp (mở rộng bản đồ)

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Bộ sưu tập được sắp xếp các cặp giá trị khóa

một đối tượng được sử dụng để đi qua một bộ sưu tập

Danh sách (mở rộng iterator)

đối tượng được sử dụng để đi qua một chuỗi

• Các lớp học
• Các lớp có sẵn trong khung thu thập thực hiện giao diện thu thập và giao diện phụ. Họ cũng thực hiện giao diện MAP và ITERATOR.

Các lớp và giao diện tương ứng của chúng được liệt kê:

• Lớp
• Tóm tắtCollection
• Danh sách Abstarctl
• Danh sách
• trừu tượng

Xếp hàng

Tóm tắt Dựa trên danh sách

LinkedList

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Lập danh sách

LinkedList

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Lập danh sách

LinkedList

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Lập danh sách

LinkedList

class TestIfElse
{
public static void main(String args[])
{
int percent = 75;
if(percent >= 75
{
System.out.println("Passed");
}
else
{
System.out.println("Please attempt again!");
}
}
}

Lập danh sách

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

LinkedList

class TestSwitch
{
public static void main(String args[])
{
int weather = 0;
switch(weather)
{
case 0 :
System.out.println("Sunny");
break;
case 1 :
System.out.println("Rainy");
break;
case 2 :
System.out.println("Cold");
break;
case 3 :
System.out.println("Windy");
break;
default :
System.out.println("Pleasant");
}
}
}

Lập danh sách

Danh sách, có thể nhân bản và có thể nối tiếp

Tóm tắt

Bộ

Trình bày

Hashset

• Hàng đợi ưu tiên
• Cây
• Vector
• Cây rơm
• Hashtable
• Bản đồ, có thể nhân bản và có thể nối tiếp
• Thực hiện danh sách mảng
• // Sử dụng các phương thức của lớp danh sách mảng
• Thực hiện Hashset
• Thực hiện đặt cây
• Thực hiện lớp Vector
• Xếp chồng thực hiện lớp