Java weekly (week 1)

According to the online courses on station b and the relevant materials of Java, the relevant knowledge of Java is sorted out

catalogue

Chapter I

1. Notes

2. Identifier rules

3. Keywords / reserved words

4. Variables

5. Constant

6. Basic data type

Integer variables and constants

Floating point variables and constants

Character variables and constants

Boolean type variables and constants

 7. Type conversion

Automatic type conversion

Cast type

8. Operator

Arithmetic operator

Assignment operator and extended assignment operator

Relational operator

Logical operator

Bitwise Operators

String connector

Conditional operator (ternary operator)

9. Use Scanner to obtain keyboard input

Chapter II

1. Control statement

Select structure (if..., then...)

Loop structure (if..., continue...)

2.break and continue statements

3. Method

4. Overloading of methods

 5. recursive algorithm

Chapter III

1. Objects and classes

2. Typical class

3. Memory analysis

1. Stack

2. Reactor

 3. Method area

4. Construction method

5. Garbage collection mechanism

6. Essence of this

7.static keyword

8. Parameter value transfer mechanism

9.Java package mechanism

10.import import class

Chapter IV

 1. inherit

1. Basic knowledge of inheritance

2. Method rewriting

3.Object class

 2. encapsulation

3. Polymorphism

Chapter VII

1. Concept of array

2. Array initialization: static initialization, dynamic initialization and default initialization

3. Traversal of array

Chapter I

1. Notes

  • Single line comments: / / the following single lines are comments
  • Multiline comment: / * * / comment between two * (cannot be nested)
  • Document notes: / * * / between the second and third * are notes, which contain some explanatory text and JavaDoc tags

2. Identifier rules

  • Function: used to name variables, classes, methods and packages
  • Rules:

The identifier must begin with a letter, an underscore "-" and a dollar sign "$"

Other parts of the identifier can be any combination of letters, underscore "-", dollar sign "$" and numbers

Java is case sensitive but unlimited in length

Identifier cannot be a keyword

  • standard:

The identifier of the class name should be capitalized as much as possible (or not)

Identifiers representing methods and variables. The first word is lowercase and the second word is uppercase (e.g. eatFood())

Variables can be Chinese characters, but not recommended (int age = 18; / / yes)

Keywords / reserved words

abstractassertbooleanbreakbytecasecatchcharclass
continuedefaultdodoubleelseextendsfinalfinallyfloat
gotoifimplementsimportinstanceofintinterfacelongnative
nullpackageprivateprotectedpublicreturnshortstaticstrictfp
switchsynchronizedthisthrowthrowstransienttryvoidvolatil
constfornewsuper

4. Variables

  • Essence:

Represents an "operable storage space". The location is determined, but the content is uncertain. The space can be accessed by accessing the variable name to manipulate the space.

  • Declaration of variables

Each variable must declare a data type, which determines the storage space of the variable.

Variable elements include variable name, variable name and scope. (such as int a;)

Precautions

Each variable has a type, which can be either a basic type or a reference type

Variable name must be a legal identifier

Variable declaration is a complete statement, so each declaration must end with a semicolon

  • Classification of variables

Local variable: a variable defined in a method or statement block. From the declared position to the end of the method or statement execution (must be initialized)

Member variables: variables defined outside the method and inside the class. Subordinate to the object, the life cycle is always accompanied by the object. (it can be assigned manually or initialized automatically)

Static variables: defined using static. Subordinate to the class, the life cycle (the longest of the three) is always accompanied by the class, from class loading to unloading.

5. Constant

It usually refers to a fixed value, such as 1, 2, 3, a, b, c, true and false

In Java, the keyword final is mainly used to define constants, which are called symbolic constants. Once initialized, the value cannot be changed

6. Basic data type

Numeric type (integer, floating point): byte (1 byte), short (2 bytes), int (4 bytes), long (8 bytes), float (4 bytes), double (8 bytes)

Character type: char (2 bytes)

boolean: boolean (1-bit)

  • Integer variables and constants

Variables: byte (1 byte) [- 128-127], short (2 bytes) [- 32768-32767], int (4 bytes) [- 2147483648-2147483647], long (8 bytes)

Constant: decimal number: e.g. 2, 3, 4, 60700

Octal number: "0" starts, such as 015

Hexadecimal number: starting with "0x", such as 0x15

Binary number: starting with "0b", such as 0b0111011

Note: Java's integer constant is of type int by default. Declaring long type usually adds "L" or "L", such as 55555l

  • Floating point variables and constants

Variables: float (4 bytes) [accurate to 7 significant digits], double (8 bytes)

Constant: decimal: 3.14, 4.56

Scientific counting method: 314e2, 314e-2

Note: the default constant is double, and the declared float type should be added with "F" or "F", such as 3.14f

Floating point type is imprecise and should not be used for comparison!!

If you want to compare, you can use Java Math under the two classes: BigInteger to achieve arbitrary precision integer operation, GigDecimal to achieve arbitrary precision floating-point operation.

For example: gigdecimal a = gigdecimal valueOf(1.0/10.0);// Will get accurate results

  • Character variables and constants

Variable: char (2 bytes)

Used to represent characters in the Unicode encoding table

Escape character:

Escape character

meaning

\bBack off
\nLine feed
\renter
\tTab
\ "Double quotation mark
\ 'Single quotation mark
\\Backslash

Note: the String type is a character sequence

  • Boolean type variables and constants

Constants: true, false

Note: unlike C, 0 or non-0 integers cannot be substituted

In if, if (man) is equivalent to man==true

 7. Type conversion

  • Automatic type conversion

Data types with small capacity are automatically converted to data types with large data volume (i.e. conversion from small range to large range)

public class test{
   public static void main(String[] args){
      int a=324;
      long b=a;
      double d=a;//Can be automatically converted
      System.out.println(b);//Output 324
      System.out.println(d);//Output 324.0
      //a=b; Automatic conversion is not allowed
      //long e=3.23; Cannot convert
     float f=234323L;//Can be automatically converted
     System.out.println(f);//Output 234323.0
     //byte b2=1230; It exceeds the representation range and cannot be converted
  }
}
  • Cast type

Syntax format: (data type) variable

public class test{
  public static void main(String[] args){
    double x=3.14;
    int y=(int)x;
    char c='a';
    int d=c+1;
    System.out.println(y);//Output 3
    System.out.println(d);//Output 98
    System.out.println((char)d);//Output b
  }
}

Pay attention to data overflow

8. Operator

Arithmetic operator (+ - * /% + + -), assignment operator (=), extension operator (+ = - = * = / =), relational operator (> < > = < =! =), logical operator (& & |! ^), bit operator (&| ^ ~ > < > > > > > > > >), conditional operator (?), string connector (+)

  • Arithmetic operator

Binary operator:

Operators with left and right operands are binary operators

Binary operators do integer operations: one is Long and the result is Long; If there is no Long, the result is int

Binary operators do floating-point operations: one is double, and the result is also double; Both operands are float and the result is float

Binary operators do remainder operations: operands can be integer and floating-point, and the result is remainder

Unary operator: + +: self increment++ a: Self increment before assignment; A + +: assign value first and then increase automatically

--: self subtraction-- a: Self subtraction before assignment; A --: assignment first and then self subtraction

For example: a=10++ a; b=a; Result b=11,a=11

                     a=10; a++; b=a; Results b=11,a=10

  • Assignment operator and extended assignment operator

"=" is the assignment operator: a=3 assigns 3 to a;

Extension operators: + =, - =, * =, / = for example, a+=b is equivalent to a=a+b; Others are similar; a*=b+3 is equivalent to a=a*(b+3)

  • Relational operator

>, <, > =, < =, = (equal to)= (not equal to)

The first four are only for numerical operation and char operation, and the last two are applicable

  • Logical operator

The operand and result are Boolean

operatorexplain
Logic and&The left and right operands are true, the result is true, and the responsibility is false
Logical or|If one of the left and right operands is true, the result is true
Short circuit and&&As long as one is false, return false directly
Short circuit or||As long as one is true, return true directly
Logical non!! False is true,! True is false
Logical XOR^If the left and right operands are the same, it is false, but the difference is true

At the same time, the operator ^, & ^, \

The short circuit operator is calculated from left to right. If the value on the left can determine the result, the result will be returned directly to improve efficiency

  • Bitwise Operators

Refers to binary operations

Bitwise Operators explain
~Reverse
&Bitwise AND
|Bitwise OR
^Bitwise XOR
<<Shift left operator, which is equivalent to multiplying by two
>>Shift right operator, equivalent to dividing by two
  • String connector

"+" 

public class test {
		  public static void main(String[] args) {
		     String a="3";
		     int b=4;
		     int c=5;
		     System.out.println(a+b);//Output 34
		     System.out.println(a+c);//Output 35
             System.out.println(a+b+c);//Output 345

}
}
  • Conditional operator (ternary operator)

Syntax format: x? y: z (where x is Boolean type. If x is true, y will be returned, otherwise z will be returned)

public class test{
  public static void main(String[]args){
     int score =80;
     String type=score>60?"pass":"fail,";
     System.out.println(type);//Output pass

  }
}

Operator priority

Logical non > logical and > logical or

Parentheses can be used to make it easier to organize
 

9. Use Scanner to obtain keyboard input

import java.util.Scanner;
public class test{
  public static main(String[] args){
    Scanner scanner=new Scanner(System.in);
    System.out.println("Please enter your name");
    String name=scanner.nextLine();
    System.out.println("Please enter your hobbies");
    String favor=scanner.nextLine();
    System.out.println("Please enter your age");
    String age=scanner.nextInt();
    System.out.println(name);
    System.out.println(age);
    System.out.println(favor);
  }
}

Chapter II

1. Control statement

A statement used to control the execution order of statements in a program. There are sequential structure, selective structure and cyclic structure

  • Select structure (if..., then...)

If single choice structure {if (Boolean expression) {statement block}

public class test{
  public static void main(String[] args){
	   double d=Math.random();//Generate random numbers between 0 and 1
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//Generate random numbers between 1 and 6
	   System.out.println(a);
	   if(a<=3)
		   {System.out.println("Small");}
  }
}

If else double selection structure

public class test {
   public static void main(String[]args){
	   double d=Math.random();
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//Generate random numbers between 1 and 6
	   System.out.println(a);
	   if(a<=3)
		   {System.out.println("Small");}
	   else
		   {System.out.println("large");}
  }
}

If else if else multiple selection structure

public class test {
   public static void main(String[]args){
	   double d=Math.random();
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//Generate random numbers between 1 and 6
	   System.out.println(a);
	   if(a<=3)
		   {System.out.println("Small");}
	   else if(a==4)
		   {System.out.println("a=4");}
	   else//a> 4. Situation
		   {System.out.println("large");}
  }
}

switch structure (used to judge the situation of multiple values)

Switch (expression)

{

case value 1: statement 1; break;// The value is an integer or string, and break indicates the end of the statement

case value 2: Statement 2; break;

.......................................;

case value n: statement n; break;

default: statement; break;

}

public class test01 {
   public static void main(String[]args){
	   double d=Math.random();
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//Generate random numbers between 1 and 6
	   System.out.println(a);
	   switch(a)
	   {
	   case 1:System.out.println("a=1");break;
	   case 2:System.out.println("a=2");break;
	   case 3:System.out.println("a=3");break;
	   case 4:System.out.println("a=4");break;
	   case 5:System.out.println("a=5");break;
	   case 6:System.out.println("a=6");break;
	   default:System.out.println("Not in the range of 1 to 6");break;
	   }
  }
}
  • Loop structure (if..., continue...)

while loop: loop first and then judge

Syntax: while (Boolean expression)

{

Circulatory body

}

public class test01 {
   public static void main(String[]args){
	   int a=0;
	   int sum=0;
	   while(a<=50)
	   {
		   sum+=a;
		   a++;
	   }
	   System.out.println(sum);//Calculate 1 + 2 + 3 + 3 ++ 50, output 1275
  }
}

The do while loop is executed before judgment

public class test01 {
   public static void main(String[]args){
	   //Calculate 1 + 2 + 3 + 3 ++ fifty
	   int a=0;
	   int sum=0;
	   do
	   {
		   sum+=a;
		   a++;
	   }while(a<=50);
	   System.out.println(sum);Output 1275
  }
}

for loop

public class test01 {
   public static void main(String[]args){
	   //Calculate 1 + 2 + 3 + 3 ++ fifty
	   int sum=0;
	   for(int i=0;i<=50;i++)
	   {
		   sum+=i;
	   }
	   System.out.println(sum);Output 1275
      
  }
}

Nested loop

Set another cycle in one cycle

public class test01 {
   public static void main(String[]args){
	   //Calculate 1 + 2 + 3 + 3 ++ fifty
	   int sum=0;
	   for(int i=1;i<=5;i++)
	   {
		   for(int j=1;j<=5;j++)
		   {
			   System.out.print(" "+j);
		   }
		   System.out.print('\n');
	   }
	   
  }
}

The output result is:

Example: output 99 multiplication table

public class test {
   public static void main(String[]args){
	   int sum=0;
	   for(int i=1;i<=9;i++)
	   {
		   for(int j=1;j<=9;j++)
		   {
			   if(j<=i)
			   {
				   sum=j*i;
				   System.out.print(j+"*"+i+"="+sum+" ");
			   }
		   }
		   System.out.println();
	   }
  }
}

The output result is:

2.break and continue statements

break is used to forcibly exit the loop without executing the remaining statements in the loop

continue means to terminate this cycle and proceed to the next cycle

Tagged break and continue statements

A label is an identifier followed by a colon, such as "label:"

Function: we hope to nest another loop in one loop. Because the break and continue keywords usually only interrupt the current loop, if they are used with the tag, they will exist in the tag of the terminal.

public class test {
  public static void main(String[] args) {
	  outer:for(int i=101;i<150;i++)
	  {
		  for(int j=2;j<i/2;j++)
		  {
			  if(i%j==0)
			  {
				  continue outer;//Return directly to the external loop where i is located
			  }
		  }
		  System.out.print(i+" ");//Outputs a prime number between 101 and 150
	  }
  }
}

3. Method

Statement block: the block determines the scope of local variables. The program code in the block, as a whole, should be executed together.

Method: it is a code fragment used to complete specific functions, similar to functions in other languages.

1. Method declaration format: [modifier 1, Modifier 2,......] Return value type: {method name (formal parameter list) {Java statement;...}

2. Method call format: object name Method name (argument list)

Formal parameter: used to receive incoming data when declaring a method

Argument: the data actually passed to the method when the method is called

Return value: the method returns the data of the environment calling it after execution

Return value type: the data type of the return value agreed in advance. If there is no return value, the return value type must be void

public class test02 {
  public static void main(String[] args) {
	  test02 tm=new test02();
	  tm.print();
	  int c=tm.add(3, 40, 5)+20;
	  System.out.println(c);
	  tm.add1(30, 40);
	  
  }
  void print() {
	  System.out.println("Learning makes me happy!");
	  System.out.println("Study enriches me!");
  }
  int add(int a,int b,int c)
  {
	  int sum=a+b+c;
	  System.out.println(sum);
	  return sum;//return ends the program and returns sum
  }
  void add1(int a1,int b1) {
	  int num=a1+b1;
	  System.out.println(num);
  }
}

be careful:

  1. The number, data type, and order of the arguments must match the parameter list of the called method

  2.return statementterminates the operation of a method and specifies the data to be returned

  3. When passing parameters in method calls in Java, follow the principle of value passing (all passed are copies of data)

  4. The basic data type passes the copy value of the data

  5. The reference type passes the copy value referenced by the object, but points to the same object

4. Overloading of methods

Methods with the same name but completely different (parameter type, number of parameters and order of parameters are different)

Note: different return values and parameter names will not constitute method overloading

 5. recursive algorithm

Basic idea: call yourself

For example, the following code will output countless a's

public class test02 {
  public static void main(String[] args) {
	  a();
	  
  }
  static void a()
  {
	  System.out.println("a");
	  a();
  }
  
}

Recursive structure includes: recursive header (the condition for the end of recursion) and recursive body (when to call its own method)

The above code can only output 5 a's

Example:

Factorial 10!

public class test02 {
  public static void main(String[] args) {
	  System.out.println(a(10));
	  
  }

  static long a(int n)
  {
	  if(n==1)
	  {
		  return 1;
	  }
	  else return n*a(n-1);
  }
  
}

Chapter III

1. Objects and classes

The class is class, and the object is object and instance

public class student {

	int id;
	String name;
	int age;
	
	void study() {
		System.out.println("I'm studying hard!");
		
	}
	void play() {
		System.out.println("I was playing games!");
	}
	//The entry of program execution must have
	public static void main(String[] args) {
		student s=new student();
		s.play();
	}
}

2. Typical class

public class student {

	int id;
	String name;
	int age;
	computer c;
	void study() {
		System.out.println("I'm studying hard!"+"use"+c.brand);
		
	}
	void play() {
		System.out.println("I was playing games!");
	}
	//The entry of program execution must have
	public static void main(String[] args) {
		student s=new student();//Create an object
		s.name="Zhang San";
		s.age=18;
		s.id=123456;
		computer c1=new computer();
		c1.brand="association";
		s.c=c1;
		s.study();
		s.play();
	}
}
class computer{
	String brand;
	
}

3. Memory analysis

It is divided into three areas: stack, heap and method area

1. Stack

Stack describes the memory model of method execution. Each method called will create a stack frame (storing local variables, operands and method exits)

The JVM creates a stack for each thread, which is used to store the information of the method executed by the thread (actual parameters, local variables)

The stack is thread private and cannot be shared between threads

The storage characteristics of stack are first in first out, last in first out

Stack is automatically allocated by the system, which is fast. Stack is a continuous memory space

2. Reactor

Heap is used to store created objects and arrays (arrays are also objects)

The JVM has only one heap, which is shared by all threads

Heap is a discontinuous memory space with flexible allocation and slow speed

 3. Method area

The JVM has only one method area, which is shared by all threads

The method area is actually a heap, which is only used to store information related to classes and constants

It is used to store the permanent or unique content in the program

From the previous procedure:

4. Construction method

Used for object initialization

Key points: 1 Using the new keyword

           2. Although the constructor has a return value, it cannot define the return value type (the return value type must be this class), and a return value cannot be used in the constructor

           3. If we do not define a constructor, the compiler will automatically define a parameterless constructor. If it is defined, the compiler will not automatically add it

           4. The constructor's method name must be consistent with the class name

class point {
  double x,y;
  public point(double m_x,double m_y) {
	  x=m_x;
	  y=m_y;
  }
  public double getdistance(point p) {
	  return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));//Calculate the distance between two points
  }
  
}
class test{
	public static void main(String[] args) {
		point p=new point(3.0,4.0);
		point p1=new point(0.0,0.0);
		System.out.println(p.getdistance(p1));
	}
}

Overloading of construction methods

5. Garbage collection mechanism

Function: 1 Useless objects found

           2. Reclaim memory space occupied by useless objects

Related algorithms:

        1. Citation counting method

Each object in the heap has a reference count. If it is referenced once, the count increases by 1. If the value of the referenced variable becomes ULL, the count decreases by 1 until the count is 0, indicating that there are no objects.

        2. Citation reachability method

The program regards all reference relationships as a graph. Starting from a node GC ROOT, it looks for the corresponding reference node. After finding this node, it continues to look for the reference node of this node. When all reference nodes are found, the remaining nodes are considered as unreferenced nodes, that is, useless nodes.

6. Essence of this

The essence is "the address of the created object". Since the object has been created before the construction method is called, this can also be used to represent the "current object" in the construction method.

public class testthis {
  int a,b,c;
   testthis(int a,int b){
	   this.a=a;
	   this.b=b;
   }
   testthis(int a,int b,int c){
	   this(a,b);//Call construction method
	   this.c=c;
   }
   void sing() {
	 System.out.println("sing");
   }
   void eat() {
	   this.sing();
	   System.out.println("Go home for dinner!");
   }
   public static void main(String[] args) {
	   testthis s=new testthis(2,3);
	   System.out.println(s.a);
	   System.out.println(s.b);
	   System.out.println(s.c);
	   s.eat();
   }
}

this cannot be used in static methods

7.static keyword

In a class, the member variables declared with static are static member variables, also known as class variables. The life cycle of class variables is the same as that of the class and is valid during the execution of the whole application.

Member variables and methods modified by static are subordinate to classes, while ordinary variables and methods are subordinate to objects.

Shared by all objects of the class

Can be called by class name and object name

static access:

Static and non member variables and methods

Static member methods can only access static member variables and methods

Static initialization block

For example: static{

System.out.println("output");

}

8. Parameter value transfer mechanism

The basic data type value passes a copy of the value

The value passed by the reference type is the copy passed, but the reference points to the address. Both the copy and the original parameter point to an address. Therefore, changing the value of the address pointed by the copy means changing the value of the object pointed by the original parameter.

9.Java package mechanism

Package mechanism is an important means of managing classes in Java. During development, we will encounter a large number of classes with the same name. Through package, we can easily solve the problem of class name duplication, and also realize the effective management of classes. Package for classes is equivalent to folder for files.

1. It is usually the first non annotative statement of the class

2. Package name: the domain name can be written upside down, plus the module name, which is convenient for internal management.

10.import import class

Java will import Java by default Lang package, so we can call these classes directly

If you import two classes with the same name, you can only use package class + class name to display the relevant classes called

Chapter IV

Three characteristics of object-oriented: inheritance, encapsulation and polymorphism

 1. inherit

1. Basic knowledge of inheritance

public class testexend {
   public static void main(String[] args) {
	   student s= new student();
	   s.name="Zhang San";
	   s.age=20;
	   s.school="university";
   }
}
class person{
	String name;
	int age;
	public void rest() {
		System.out.println("Take an hour off!");
	}
}
class student extends person{//student inherits the members of the person class
	String school;
	public void study() {
		System.out.println("Study for an hour!");
	}
	
}

Key points: 1 Parent classes are also called superclasses, base classes, and derived classes

           2. In Java, there is only single inheritance, not multiple inheritance

           3. There is no multi inheritance in Java classes, and there is multi inheritance in interfaces

           4. The subclass inherits from the parent class and can get all the properties and methods of the parent class (except the construction method of the parent class), but it may not be directly accessible (such as private)

           5. If you define a class without calling extends, its parent class is Java lang.Object

instanceof is a binary operator. On the left is an object and on the right is a class. If the object is an object created by a class or subclass on the right, the return value is true.

public class testexend {
   public static void main(String[] args) {
	   student s= new student();
	   s.name="Zhang San";
	   s.age=20;
	   s.school="university";
	   s.rest();
	   s.study();
	   System.out.println(s instanceof student);
	   System.out.println(s instanceof person);
	   System.out.println(s instanceof Object);
   }
}
class person{
	String name;
	int age;
	public void rest() {
		System.out.println("Take an hour off!");
	}
}
class student extends person{
	String school;
	public void study() {
		System.out.println("Study for an hour!");
	}
	
}

2. Method rewriting

By overriding the method of the parent class, a subclass can replace the behavior of the parent class with its own behavior.

Key points: 1 "= =": the method name and parameter list are the same

           2. "< =": return value type and declared exception type, subclass less than or equal to parent class

           3. "> =": access permission. The subclass is greater than or equal to the parent class

public class testoverride {
  public static void main(String[]args) {
	  son s=new son();
	  s.work();//Override the work method of the parent class
  }
}
class father{
	public void work() {
		System.out.println("Work for a while");
	}
	public father play() {
		return new father();
	}
}
class son extends father{
	public void work() {
		System.out.println("Stop working");
	}
	public son play() {
		return new son();//The return value type is less than or equal to the type of the parent class
	}
}

3.Object class

toString method: the source code is:

public String toString(){
   return getClass().getName()+"@"+Tnteger.toHexString(hashCode());
}

Rewrite:

public class testobject {
  public static void main(String[] args) {
	 testobject to=new testobject();
	 System.out.println(to.toString());//The output is similar: testobject@515f550a
	 person p=new person();
	 p.name="Zhang San";
	 p.age=19;
	 System.out.println(p.toString());
  }
  public String toString() {
	  return "rewrite";
  }
}
class person{
	String name;
	int age;
	public String toString() {
		return name+"Age:"+age;
	}
}

equals method: the source code is:

public boolean equals(Object obj){
   return (this == obj);
}
public class testequals {
   public static void main(String[] args) {
	   person t1 = new person(67890,"Wang Wu");
	   person t2 = new person(12345,"Li Si");
	   System.out.println(t1==t2);
	   System.out.println(t1.equals(t2));
   }
   
}
class person{
	int id;
	String name;
	public person(int id,String name)
	{
		this.id=id;
		this.name=name;
	}
	
}

Rewrite:

import java.util.Objects;

public class testequals {
   public static void main(String[] args) {
	   person t1 = new person(12345,"Wang Wu");
	   person t2 = new person(12345,"Li Si");
	   System.out.println(t1==t2);
	   System.out.println(t1.equals(t2));
   }
   
}
class person{
	int id;
	String name;
	public person(int id,String name)
	{
		this.id=id;
		this.name=name;
	}
	@Override
	public int hashCode() {
		return Objects.hash(id);
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		person other = (person) obj;
		return id == other.id;
	}
	
}

Right click - source - as shown in the figure, which can automatically generate rewrites according to the selection

 

Super is a direct reference to the parent class object. You can access the methods or properties in the parent class that are overridden by the child class through super

public class testsuper {
  public static void main(String[] args) {
	  //father f=new father();
	  son s=new son();
	  s.f();
  }
}
class father{
	public int num;
	public void f() {
		num=100;
		System.out.println("father.num="+num);
	}
}
class son extends father{
	public int num;
	public void f() {
	num=200;
	System.out.println(num);//Output 200
	super.f();//Call the normal method of the parent object and output father num=100
	System.out.println(super.num);//Call the normal method of the parent object and output 100
	System.out.println("son.num="+num);//Output son num=200
	}
}

Inheritance tree tracing

The first sentence of the construction method is always: super (...) To call the construction method of the parent class. Therefore, the process is: first trace back to Object, and then execute the initialization block and construction method of the class downward until the current subclass is known.

 2. encapsulation

Access control character

  

Modifier Same classSame packageSubclassAll classes
private×××
default××
protected×
public

Private: it means private and can only be accessed by yourself

default: indicates that there is no modifier, and only classes of the same package can access it

protected: indicates that it can be accessed by classes of the same package and subclasses of other packages

public: can be accessed by all classes in all packages of the project

Key points: 1 Class properties are generally private

            2. Provide corresponding set and get methods to access relevant properties

            3. Some auxiliary methods that are only applicable to this class can be modified with private

3. Polymorphism

It refers to the same method call, which may have different behaviors due to different objects.

Key points: 1 Polymorphism is the polymorphism of methods, not attributes (polymorphism has nothing to do with attributes)

            2. There are three necessary conditions for polymorphism: inheritance, method rewriting, and parent class reference pointing to child class objects

            3. After the parent class reference points to the child class object, call the method overridden by the child class with the parent class reference. At this time, polymorphism appears.

public class testpolyme {
  public static void main(String[] args) {
	  animalaa(new animal());
	  animalaa(new dog());
	  animalaa(new cat());
	  
  }
  static void animalaa(animal a) {
	  a.shout();
  }
}
class animal{
	public void shout() {
		System.out.println("Let out a cry");
	}
}
class dog extends animal{
	public void shout() {
		System.out.println("Woof, woof");
	}
}
class cat extends animal{
	public void shout() {
		System.out.println("cat ");
	}
}

Object transformation

animal d=new dog(); Convert dog to animal class, and now D is animal class

dog d2=(dog)d; Convert dog of animal class to dog class

finall keyword

1. Modified variable: the variable modified by it cannot be changed. Once a value is assigned, it cannot be re assigned

2. Modification method: this method cannot be overridden by subclasses, but can be overloaded

3. Modified class: modified classes cannot be inherited

Chapter VII

1. Concept of array

An array is an ordered collection of data of the same type, and each element can be accessed by subscript

Features: 1 The length is definite

           2. Elements must be of the same type

           3. The data type can be any data type

Arrays are objects

Declaration of array: type[] name or type name [];

2. Array initialization: static initialization, dynamic initialization and default initialization

public class test01 {
  public static void main(String[] args) {
	  //initiate static
	  int[] a= {2,3,5};
	  user[] b= {
			      new user("Zhang San",10),
			      new user("Li Si",20),
			      new user("Wang Wu",30),
	            };
	  //Default initialization
	  int[] c=new int [3];//Assign values to elements by default
	  //dynamic initialization
	  int [] d=new int[2];
	  d[0]=3;
	  d[1]=9;
	  
  }
}
class user{
	public String name;
	public int age;
	user(String name,int age){
		this.name=name;
		this.age=age;
	}
}

3. Traversal of array

Traversal: initial and read

foreach loop, which is used to read the value of array elements. The value of elements cannot be modified

package cn.dd;

public class test03 {
	 public static void main(String[] args) {
	   int[]a=new int[4];
	   for(int i=0;i<a.length;i++)
	   {
		   a[i]=2*i;
	   }
	   for(int i=0;i<a.length;i++)
	   {
		   System.out.println(a[i]);
	   }
	   //foreach loop, which is used to read the value of array elements. The value of elements cannot be modified
	   for(int m:a) {
		   System.out.println(m);
	   }
	   
	 }
}

Tags: Java

Posted by archonis on Tue, 03 May 2022 18:31:31 +0300