Introduction to object-oriented features of java

Java’s three major object-oriented features:

Encapsulation, inheritance, and polymorphism.

1. Encapsulation

Hides the class information inside the class and does not allow direct access by external programs. Instead, the hidden information is implemented through the methods provided by the class. operations and access.

Encapsulation implementation steps:

Modify the visibility of the attribute: set to private

Create getter/setter methods: for reading and writing attributes

Add attribute control statements to the getter/setter method: judge the legality of the attribute value

(Recommended learning: java video tutorial)

Modify the visibility of attributes using private, for example:

//表示读取该方法中的screen
public float getScreen{
	return screen;
    }
 //有viod无返回值，变量名.属性=值，就不能直接调用可以通过变量名.getScreen()来实现
public viod setScreen(float newScreen){
	screen = newscreen；
	}

Variable name. Attribute = value cannot be called directly. It can be achieved through variable name.getScreen().

Function of package:

1.Manage Java files

2.Resolve file conflicts with the same name

Definition package: package

Package name Note: It must be placed in the first line of the Java source program. Package names can be separated by ".". For example: in com.imooc.MyClassJava, the naming convention of the package is all lowercase letters.

Access control modifiers in Java

public, default, protected, private

public: public, accessible to all classes

default: Default modifier, access within the same package

protected: Protected type. Outsourced classes in the same package and that inherit this class can access

private: Private class, only this class can access

final, finally, finalize (in inheritance)

final: modifier. The class modified by this modifier cannot be inherited; the variable modified by this modifier cannot be modified and can only be read; the method modified by this modifier can only be used, can be overloaded, and cannot be overwritten; this modification Symbols cannot modify abstract classes.

finally: Cleanup operation after catching an exception

finalize: a method; mainly before the GC deletes the object, first call the finalize method on the object to determine whether the object is referenced

This keyword in Java

//原来手动输入
public void setScreen( float newScreen){
   screen = newScreen;
   }
// 用eclips 自动生成的是
public void setScreen( float newScreen){
  this.screen = screen;
  }

this.Attribute: Manipulate the properties of the current object

this.Method: Call the method of the current object

Ecilipse can directly generate setter and getter methods and add this keyword.

This keyword calls member variables or member methods static members. This and super keywords cannot be used in static methods. At the same time, you can also return a reference to the class and call the constructor

Static inner classes in Java

Static inner classes are static-modified inner classes. The characteristics of this kind of inner class are:

1. Static inner classes cannot directly access external classes. Non-static member, but can be accessed through new outer class (). member.

2. If the static members of the outer class have the same name as the member of the inner class, you can access the static members of the outer class through "class name.static member"; if the static members of the outer class have the same name as the member of the inner class If they are not the same, you can directly call the static members of the external class through the "member name".

3. When creating an object of a static inner class, you do not need an object of an outer class. You can directly create an inner class object name = new inner class ();.

2. Inheritance

The concept of inheritance: It is a relationship between classes.

Benefits of inheritance:

1) The subclass has all the properties and methods of the parent class (private modification is invalid)

2) Implement code reproduction

Grammar rules: class subclass extends parent class { }

Rewriting of methods:

If the subclass is not satisfied with the inheritance of the parent class, rewrite its own Content and after rewriting, the subclass method will be called first

Grammar rules:

The return value, type, method name, parameter type number must be the same as the parent class integration method , is called overriding

Inherit the initialization sequence:

Parent class attribute initialization>Parent class construction method>Subclass attribute initialization>Subclass construction method 0

super keyword:

is used inside the object and can represent the parent class object.

Access the attributes of the parent class: super.age;

The method of accessing the parent class: super.eat();

Application of super:

During the construction method of the subclass, the construction method of the parent class must be called.

If the constructor of the subclass does not explicitly call the constructor of the parent class, the system calls the parent class's no-argument constructor by default.

If you call the constructor explicitly, it must be in the first line of the subclass's constructor.

If the subclass constructor does not explicitly call the constructor of the parent class, and the parent class does not have a parameterless constructor, a compilation error will occur.

Object class:

No identification of whose class is inherited is equivalent to inheriting the Object class

toString() method:

The hash code (object address string) of the object returned when the toString() method is defined in the Object class

The object can be represented by overriding the toString() method Attribute

equals() method:

The comparison is whether the object reference points to the same memory address. Note: The equals() method is not applicable when comparing two objects. When a new object is created, a new storage address will be created in the memory. Therefore, even if the object attributes are consistent, they are not equal. To compare the specific attribute values ​​of the objects to be the same, you need to repeat Write the equals() method

Compare getClass() and return the class object:

getClass() returns the class object: code information that describes the class. The attributes of the class are Which, what is the type, what is the variable name, what is the method name, what is more concerned about is the code information of the class.

Create an object name and return the object of the class:

Focus on the attribute value information of the object, or the information of the object data

3. Polymorphism

Polymorphism: refers to the various forms of objects, mainly divided into reference polymorphism and method polymorphism.

Inheritance is the basis for polymorphism. Don’t forget that child and parent classes must have an inheritance relationship.

Polymorphic features:

1. Reference Polymorphism

The parent class reference can point to the object of this class Animal obj1 = new Animal();

The parent class reference can point to the subclass object Animal obj2 = new Dog();

But we cannot use the reference of the subclass to point to the parent class object Dog obj3 = new Animal(); //Error

2. Method polymorphism

Define an eat() in class Animal method, output a statement (animals have the ability to eat); rewrite the eat() method in the subclass Dog, output a statement (dogs eat meat); then in the main function of the test class, if obj1.eat( ), then the method of the parent class is called. If obj2 is used to call the eat() method, then the method of the subclass is called.

There is another situation, such as creating a subclass Cat that inherits the parent class Animal, but the inherited eat() method is not overridden in Cat. Then, we create a subclass in the main function of the test class Object, Animal obj3 = new Cat(); and then call obj3.eat(); Then, the result is that the subclass inherits the method of the parent class. (Output result: The animal has the ability to eat).

In the last special case, polymorphic features cannot be used. If you add a unique method public void watchDoor() to the subclass, containing an output statement (the dog has the ability to watch the door); Then in the main function of the test class (we must first define the object Animal obj2 = new Dog()), we cannot use obj2.watchDoor(), that is, we cannot call the method of the subclass through the reference of the parent class.

Recommended related articles and tutorials: java introductory tutorial

The above is the detailed content of Introduction to object-oriented features of java. For more information, please follow other related articles on the PHP Chinese website!