JAVA

I- BASIC JAVA
1. Scanner
*import java.util.Scanner;
Khai báo: Scanner /tên scanner/ = new Scanner(System.in);
Cách dùng: /kiểu dữ liệu/ /tên biến/ = /tên scanner/.next/tên kiểu dữ liệu/();
VD: Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
2. Random
*import java.util.Random;
Khai báo: Random /tên random/ = new Random();
Cách dùng: /kiểu dữ liệu/ /tên biến/ = /tên scanner/.next/tên kiểu dữ liệu/(khoảng
random);
VD: Random dice = new Random();
Int x = dice.nextInt(6)+1;
Chú ý: -Nếu khoảng random là x thì giá trị random sẽ chạy từ 0 tới x – 1
-Nếu kiểu dữ liệu là Double thì khoảng random sẽ là từ 0 đến 1
3. Array
Khai báo: /kiểu dữ liệu/[ ] /tên mảng/ = new /kiểu dữ liệu/[size];
Cách dùng: /tên mảng/[index] = /giá trị/;
VD: int[] k = new int[2];
k[0] = 6;
k[1] = 2;
4. 2D Array
Khai báo: /kiểu dữ liệu/[ ][ ] /tên mảng/ = new /kiểu dữ liệu/[size x] [size y];
Cách dùng: /tên mảng/[index x] [index y]= /giá trị/;
VD: int[ ] [ ] k = new int[2][3];
k[0][0] = 6;
k[0][1] = 2;
k[0][2] = 1;
k[1][0] = 3;
k[1][1] = 4;
k[1][2] = 5;
5. String method
Dùng cho kiểu dữ liệu String
1 số methods thường dùng;
 equals(/String2/): so sánh 2 String
 equalsIgnoreCase(/String2/): so sánh 2 String mà không quan tâm viết hoa
 length(): độ dài String
 charAt(index): tìm kí tự tại vị trí *index*(nếu index vượt quá =>lỗi)
 indexOf(‘/kí tự/’): tìm chỉ số nhỏ nhất của kí tự(nếu không có kí tự thì return -1)
 indexOf(“/chuỗi/”): tương tự
 isEmpty(): kiểm tra String có rỗng không
 toUpperCase(): viết hoa toàn bộ >< toLowerCase(): viết thường toàn bộ
 replace(‘x’, ‘y’): thay toàn bộ kí tự x bằng kí tự y
*Có thể dùng method với 1 số kiểu dữ liệu khác khi khai báo dữ liệu ta
viết hoa và đầy đủ tên kiểu dữ liệu(VD: Integer x)
6. Array List
*import java.util.ArrayList;
Khai báo: ArrayList</tên kiểu dữ liệu*/> /tên ds mảng/ = new ArrayList();
Cách dùng: /tên ds mảng/.add(/giá trị/);
*tên kiểu dữ liệu phải viết hoa và đầy đủ
VD: ArrayList<Integer> height = new ArrayList();
height.add(182);
height.add(172);
7. 2D Array List
*import java.util.ArrayList;
Khai báo: ArrayList<ArrayList</tên kiểu dữ liệu/*>> /tên ds mảng/ = new
ArrayList();
/* tạo mảng con*/
/tên ds mảng/.add(/tên mảng con/);
*tên kiểu dữ liệu phải viết hoa và đầy đủ
VD: ArrayList<ArrayList<String>> human = new ArrayList();
ArrayList<String> male = new ArrayList();
ArrayList<String> female = new ArrayList();
human.add(male);
human.add(female);
 8. Methods
*1 Methods được khai báo sau public class main
Khai báo: (static) /kiểu dữ liệu/ /tên methods/(/biến/){}
VD: static int sum(int x, int y){
return x+ y;
}
II- OOP
1. Object
New -> Class -> Đặt tên Class
Trong Class khai báo các thuộc tính và methods của Object
VD: public class Car {
String name = "BMW";
int mass = 250;
double speed = 350.5;
void drive(){
System.out.println("You drive the car");
}
}
Khai báo: /tên class/ /tên tùy chọn/ = new /tên class/();
Cách dùng: /tên tùy chọn/./tên method hoặc thuộc tính/();
VD: Car mycar = new Car();
System.out.println(mycar.mass());
mycar.drive();
2. Constructor (Có thể khai báo tên khác nhau cho mỗi đối tượng)
*Trong class
Khai báo: khai báo các thuộc tính và không gán giá trị
Tạo hàm bằng cú pháp:
/tên class/(/kiểu dữ liệu các thuộc tính/){
this./thuộc tính/ = /thuộc tính/;
}

Tạo method: Tương tự như phần 1, nhưng khi truy cập đến các thuộc tính
thì sử dụng this./thuộc tính/
 VD: String name;
int age;
double height;
Human(String name, int age, double height){
this.name = name;
this.age=age;
this.height = height;
}
void introduce(){
System.out.printf("%s is %d years old and his height is %f cm",
this.name, this.age, this.height);
}
*Trong main
Khai báo: /tên class/ /tên tùy chọn/ = new /tên class/(/các thuộc tính/);
Cách dùng: /tên tùy chọn/./tên method hoặc thuộc tính/();
VD: Human human1 = new Human(“Huy”, 19, 172);
human1.introduce();
3. Array of Objects (Mảng đối tượng)
Khai báo:
C1: /tên class/[ ] /tên mảng/ = new /tênclass/[size];
Sau đó tạo các objects rồi gán
VD: Car[ ] garage = new Car[2];
Car car1 = new Car(“BMW”);
Car car2 = new Car(“Merc”);
garage[0] = car1;
garage[1] = car2;
 C2: Tạo các object
/tên class/[ ] /tên mảng/ = {/các objects/};
VD: Car car1 = new Car(“BMW”);
Car car2 = new Car(“Merc”);
Car[ ] garage = {car1, car2};
Cách dùng: Tương tự với các objects thông thường, chỉ thêm chỉ số
4. Truyền đối tượng (Sử dụng object như 1 biến)
Khai báo: ở Class chứa object ta cần khai báo object đó
VD: *class Human:
String name;
Human(String name){
this.name = name;
}
 *class Car:
String name;
Car(String name){
this.name = name;
}
void drive(Human human1){
System.out.println(human1.name+” is driving the “+this.name”);
*class Main
Car car1 = new Car(“BMW”);
Human human1 = new Human(“Jack”);
Car.drive(human1);
5. Static keywords
-có thể dùng với biến hoặc methods trong class, khiến cho biến hoặc
methods trở thành đặc tính chung của bất kể bao nhiêu đối tượng được
thành lập, giúp tiết kiệm bộ nhớ
Cú pháp: static /kiểu dữ liệu/ /tên biến hoặc method/;
VD: *Class Car
String name;
static String KindOfCar = “pedal”;
static int numberOfCar;
Car(String name){
numberOfCar++;
this.name = name;
}
*Class Main
Car car1 = new Car(“BMW”);
Car car2 = new Car(“Vinfast”);
System.out.println(Car.KindOfCar);
System.out.println(Car.numberOfCar);
6. Kế thừa
Sử dụng khi có 1 class (con) bao gồm tất cả các thuộc tính của 1 class
khác (cha)
Cú pháp: public class /tên class con/ extends /tên class cha/{}
VD: *Class Vehicle
public class Vehicle{
Void go(){
System.out.println(“This vehicle is going”);
}
}
*Class Car
public class Car extends Vehicle{
int wheels;
int doors;
Car(int wheels, int doors){
this.wheels = wheels;
this.doors = doors;
}
}
*Class Main
Car car1 = new Car(4, 4);
car1.go();

*Chú ý: Ghi đè phương thức (method overriding): khi ta có 2 method

giống nhau ở cả Class cha và Class con, chương trình sẽ ưu tiên thực
hiện method ở Class con khi gọi đến
7. Super keyword
Sử dụng khi muốn gọi đến biến hoặc methods của Class cha ở Class con
Cách dùng: *Biến: super(/các biến cần gọi/);
*Method: super./tên method cần gọi/();
 VD: *Class Vehicle
public class Vehicle{
String name;
double speed;
Vehicle(String name, double speed){
this.name = name;
this.speed = speed;
}
public String toString(){
return this.name + “\t” + this.speed;
}
}
*Class Car
public class Car extends Vehicle{
int wheels;
int doors;
Car(String name, double speed, int wheels, int doors){
super(name, speed);
this.wheels = wheels;
this.doors = doors;
}
public String toString(){
return super.toString() + “\t” + wheels + “\t” + doors;
}
}
*Class Main
Car car1 = new Car(“BMW”, 360.6, 4, 4);
System.out.println(car1.toString());
8. Abstract keyword (trừu tượng)
-Khi sử dụng Abtract với 1 class, cần có 1 class kế thừa và không thể khởi
tạo lớp trừu tượng đó ở class Main
-Abstract method được khai báo trong Abstract class, và cần được ghi đè
(override) ở class kế thừa
VD:
 Class Shape
public abstract class Shape {
abstract double s();
}
  Class Circle
public class Circle extends Shape {
double r;
Circle(double r){
this.r = r;
}
double s() {
return 3.14*r*r;
}

}
 Class Main
Circle c = new Circle(4);
System.out.println(c.s());
9. Các kiểu truy cập (Package => Class)
VD: Cho cấu trúc gồm 2 Package đã được import vào nhau
Package 1: Class A, Class B
Package 2: Class C, Class Asub(Class con của A)

 Default: có thể truy cập khi cùng Package

*Class B: String defaultMassage = “default”;
*Class A: B b = new B();
System.out.println(b.defaultMassage);

 Public: có thể truy cập ở mọi vị trí trong Project

*Class B: public String publicMassgae = “public”;
*Class C: B b = new B();
System.out.println(b.publicMassage);

 Protected: có thể truy cập từ Class con

*Class A: protected String protectedMessage = “protected”;
*Class Asub: Asub asub = new Asub();
System.out.println(A.protectedMassage);
  Private: chỉ có thể truy cập trong cùng Class
*Class B: private String privateMassgae = “private”;
System.out.println(privateMassage);

Lưu ý: muốn run Class nào cần public static void main(String[ ] args){}

10. Encapsulation (Tính đóng gói)

-Khi 1 số biến hay method được khai báo private, nếu muốn truy cập
cần phải dùng đến 1 số method đặc biệt
 Getter: method lấy giá trị của biến đó
Khai báo: public /kiểu dữ liệu/ get/biến/(){
return /biến/;
}
VD: *Class Car
private int year;
private String name;
Car(String name, int year){
this.name = name;
this.year = year;
}
public String getname(){
return name;
}
public String getyear(){
return year;
}
*Class Main
Car car1 = new Car(“BMW”,2021);
System.out.println(car1.getyear());

 Setter: method thay đổi giá trị của biến đó

Khai báo: public /kiểu dữ liệu/ set/biến/(){
this./biến/ = /biến/
}
*Constructor:
/tên class/(/kiểu dữ liệu/ /biến/){
this.set/biến/(/biến/);
}
 VD: *Class Car
private int year;
private String name;
Car(String name, int year){
this.setname(name);
this.setyear(year);
}
public void setname(){
this.name = name;
}
public void setyear(){
this.year = year;
}
*Class Main
Car car1 = new Car(“BMW”, 2010);
car1.setyear(2021);
11. Copy object
-Khi ta có sẵn 2 Object và muốn sao chép từ Object 2 sang Object 1, nếu
chỉ sử dụng lệnh /Object 1/ = /Object 2/ thì chương trình chỉ đơn thuần
sao chép vị trí của Object 2 đến Object 1, hay 2 Object là chung vị trí
trong tệp tên nhưng chỉ khác tên. Ta cần xây dựng 1 method copy
Khai báo: public void copy(/tên class/ /tên bất kỳ/){
this.set/biến/(/tên bất kỳ/.get/biến/());
}
Cách dùng: /Object copy/.copy(/Object cần copy/);
VD: public void copy(Car x){
this.setmodel(x.getmodel());
this.setname(x.getname());
this.setyear(x.getyear());
}
* Nếu có 1 Object và muốn tạo 1 Object mới giống với Object cũ, ta
dùng:
Khai báo: /Tên class/(/tên class/ /tên bất kỳ/){
this.copy(/tên bất kỳ/);
}
Cách dùng: /tên class/ /object mới/ = new /tên class/(object cũ);
VD: Class Car Class Main
Car(car x){ Car car2 = new Car(car1);
This.copy(x);
 }

12. Mức độ truy suất:

13.

14.Hàm đặc biệt

toString:tự động hiển thị hết những thông tin thuộc tính(phải có return)
15.
16.Khacs nhau về signature.
17.-Interface(lớp cha) chỉ được chứa các hằng số( static final) hoặc các phương
thức abstract.: public interface A{}
-Lớp con được dẫn xuất từ interface bắt buộc phải override lại các phương
thức(theo đúng tc của abstract).:public class B implements A{}