java object-oriented programming 1 -- classes and class members

Process oriented (pop) vs object oriented (oop)

​ Process oriented is a kind of functional behavior. It takes function as the minimum unit and considers how to do it

​ Object oriented emphasizes the objects with functions, taking class / object as the minimum unit and considering who will do it

Two basic elements of Java object-oriented programming: Class - > object

Use and instantiation of classes

  • Class: the description of a class of things, which is an abstract and conceptual definition.

  • Object: it refers to each individual, concrete and instance of such things that actually exist.

  • Class members: attributes (member variables), methods ()

Steps for using classes and objects:

  1. Create class, and design class members (key)
  2. Create an object of a class (instantiation of a class)
  3. Call the structure [object variable name. Attribute or object variable name. Method] in the class through the object of the class

Class member 1: use of attributes:

​ Attribute (member variable) VS local variable

  1. Attribute is declared in {} of class

    Local variables are variables declared in methods, method parameters, constructors, constructor parameters, and code blocks

  2. Attributes can be modified with permission modifiers; Local variables are not allowed

    Common permission modifiers: private\public\ default \protected

  3. Attribute has default initialization value; No local variables

    Default initialization value for property:

    ​ Integer variable (int\short\byte\long): 0

    ​ Floating point variable (float\double): 0.0

    ​ Boolean variables: false

    ​ Application type variable (array, class, interface): null

  4. Attributes are stored in memory in the heap

    Local variables are stored on the stack in memory

Class member 2: Method usage:

  • Method declaration:

    Permission modifier return value type method name (formal parameter list){

    ​ Method body;


    1. Return value types can be divided into two types: with return value and without return value

      ① With return value: specify the return data type when declaring; Use the return keyword in the method body to return a variable or constant of the specified type

      ② No return value: declared with void; Normally, the return keyword is not used, but if it is used, only return can be used—— Indicates the end of the method

    2. Format of formal parameter list: data type 1 variable name 1, data type 2 variable name 2······

  • Object array:
    Array elements are classes
    Exercise: define class Student, which contains three attributes: Student number(int), grade state(int), and score(int). Create 20 Student objects with Student numbers from 1 to 20. Grades and grades are determined by random numbers. Question 1: print out the Student information of grade 3 (the state value is 3). Question 2: use bubble sorting to sort students' grades and traverse all Student information


public class Exer1 {
	public static void main(String[] args) {
		Student[] array = new Student[20];
		for(int i=0;i<array.length;i++) {
			//Assign values to array elements
			array[i] = new Student();
			//Assign values to each attribute of an element
			array[i].number = i+1;
			array[i].state = (int)(Math.random()*9)+1;
			array[i].score =(int)(Math.random()*101)+0;
		Exer1 ss = new Exer1();
		ss.searchState(array, 3);
	//Traversal array
	public void print(Student[] array1) {
		for(int i=0;i<array1.length;i++) {
	 * Find the student information of the specified grade in the Sudent array
	 * @param array1 Specify array
	 * @param state Grade to find
	public void searchState(Student[] array1,int state) {
		for(int i=0;i<array1.length;i++) {
		if(array1[i].state==state) {
				//System.out.println(array[i]);// Address value
	 * Bubble sort the Student array
	 * @param array1
	public void sortState(Student[] array1) {
		for(int i=0;i<array1.length-1;i++) {
			for(int j=0;j<array1.length-1-i;j++) {
				if(array1[j].score>array1[j+1].score) {
					//int temp = array[j].score;
					//array[j].score = array[j+1].score;
					//array[j+1].score = temp;
		//Important: the array element student is exchanged in order, not the student's grade
					Student temp = array1[j];
					array1[j] = array1[j+1];
					array1[j+1] = temp;
class Student{
	int number;//Student ID
	int state;//grade
	int score;//achievement
	//Output student information, you can write a method
	public String info() {
		return "Student No.:"+number+", Age:"+state+", Results:"+score ;
  • Method overloads: overloads are formed between several methods of the same class, method name and parameter list

    ​ Note: ① formal parameter list: number of parameters and data type (order) of parameters ② it is independent of permission modifier and return value type

  • Variable number of formal parameters

    Format: data type Variable name

    You can pass in multiple formal parameters of the same data type (similar to an array)

    The definition of a variable parameter can only be declared at the end and has only one

  • Value Passing Mechanism of method parameters

    (focus on understanding the structure of local variables - stack, attributes and new - heap by drawing memory analysis diagram)

    Value Passing Mechanism: ① if the parameter is a basic data type, the actual parameter is assigned to the formal parameter with the actual stored data value of the actual parameter

    ② If the parameter is a reference data type, the address value of the stored data of the parameter is assigned to the formal parameter by the parameter

  • Call of recursive method

    Calling its own method in a method is called recursion

* Use of recursive methods:
* Example: a sequence of numbers is known: f(0)=1;f(1)=4,f(n+2)=2*f(n+1)+f(n)
* 		Find the value of f (10)
public class Exer3 {
   public static void main(String[] args) {
   	Exer3 exe = new Exer3();
   	int f = exe.f(10);
   public int  f(int n) {
   	if(n==0) {
   		return 1;
   	}else if(n==1) {
   		return 4;
   	}else {
   		return 2*f(n-1)+f(n-2);

Class member 3: constructor

  1. Functions: ① create objects; ② Information about the initialization object

  2. Format: permission modifier class name (formal parameter list){

    ​ }

  3. explain:

    • By default, the system provides a null parameter constructor with the same permissions as the class; Once the constructor is explicitly defined, the system no longer provides an empty parameter constructor
    • Overloads also exist between constructors (see the formal parameter list: number of parameters and parameter types)
    • At least one constructor in a class
  4. Assignment process of attributes (sequence)

    Default initialization value - explicit assignment - assignment in constructor - assignment by "object. Attribute" or "object. Method"

Class member 4 -- code block

  1. Code block (initialization block): function: initialize classes and objects

  2. Format: {}

  3. You can only use static modification, which can be divided into static code blocks and non static code blocks according to whether static modification is used

——Static code block: static {}

​ ① Execute as the class is loaded and only once

​ ② Class information can be initialized in it (only static properties or methods can be called)

——Non static code block: {}

​ ① It is executed as the object is created. Each time an object is created, it will be executed once

​ ② Initializing an object's properties or methods

  1. Method and sequence of attribute assignment: default initialization value - explicit initialization / code block initialization (who declares first, who first) - constructor assignment - object Properties / methods

Class member 5: inner class

  1. Declare another class B inside a Class A (a -- external class, B -- internal class)

  2. Classification: member inner class: static member inner class (static decoration), non static member inner class [similar to method, parallel structure]

​ Local inner classes: within methods, code blocks, and constructors

————Member internal class: its use is viewed from two perspectives - as a member of an external class [can call the structure of an external class; modified by static and permission modifiers] and as a class [can define attributes, methods, constructors, etc.; modified by final and abstract]

​ ① How to instantiate an internal member class:

​ ② How to call the structure of an external class: pay special attention to the use of duplicate names

————Use of local internal classes in development: used more in methods

//Returns an object of a class that implements the Interface1 interface
public Interface1 getInterfaca(){
    //Create a class that implements Interface1 interface: local inner class
    //Method 1:
    class MyInterface1 implements Interface1{
    return new MyInterface1();
    //Mode 2:
    //return new MyInterface1(){}

Tags: Java

Posted by benny_g on Wed, 01 Jun 2022 22:53:59 +0530