Home >Java >javaTutorial >The logical process of Java development object-oriented programming (OOP)
Java is an object-oriented programming language (Object-Oriented Programming, OOP), and the object-oriented programming idea is a software development method, the core of which is object-based programming. Object-oriented programming can help programmers better organize and manage code, and improve code reusability, maintainability and scalability. In this article, we will help readers better understand OOP ideas and the Java language by introducing the logical process of object-oriented programming in Java development.
In Java, everything is an object, so you first need to define a class to describe the object. We can use the keyword class in Java to define a class, as shown below:
public class Person {
// 属性
private String name;
private int age;
// 方法
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}The class contains attributes and methods. The attributes are used to describe the characteristics of the object, and the methods are used to describe the behavior of the object. The above code defines a Person class, which contains two attributes name and age, and four methods setName, setAge, getName and getAge. In a class, we can use access controls (public, protected, private) to limit the visibility of properties and methods.
When the class definition is completed, we can use this class by creating objects. In Java, use the new keyword to create an object, as shown below:
Person person = new Person();
person.setName("张三");
person.setAge(20);
System.out.println(person.getName());
System.out.println(person.getAge());The above code creates a Person object, sets its name and age attributes, and finally outputs its name and age. Here we can see that the process of creating an object is completed by calling the constructor of the class, and then setting and obtaining properties through the object's methods.
In OOP thinking, encapsulation and inheritance are key concepts. Encapsulation refers to hiding the state information of an object inside the object and only providing exposed interfaces to ensure the security and maintainability of the object. Inheritance means that a class can inherit its properties and methods by extending another class, and on this basis, it can add its own properties and methods.
In Java, encapsulation and inheritance are also implemented through keywords, which are private, protected and public respectively. The scopes of these three keywords are private, protected and public respectively. For properties and methods in a class, we can use these three keywords to limit their visibility to achieve encapsulation. The sample code is as follows:
public class Person {
// 私有属性
private String name;
private int age;
// 公共方法
public void setInfo(String name, int age) {
this.name = name;
this.age = age;
}
public String getInfo() {
return "姓名：" + this.name + "，年龄：" + this.age;
}
}
public class Student extends Person {
// 私有属性
private int id;
// 公共方法
public void setId(int id) {
this.id = id;
}
public int getId() {
return this.id;
}
}In the above code, we define a Person class and a Student class that inherits from the Person class. The Person class defines two private properties name and age, as well as a public method setInfo and a public method getInfo, which are used to set and get the name and age attributes. The Student class inherits all the attributes and methods of the Person class, and adds a new private attribute id and two public methods setId and getId, which are used to set and obtain the student number attribute.
Through the above code, we can see that the attributes name and age in the Person class are defined as private attributes and can only be accessed by methods inside the class, while the public methods setInfo and getInfo are exposed to the outside for setting and get the value of the attribute. In the Student class, since it inherits the Person class, it also contains the name and age attributes. However, when the Student class object sets the name and age attributes, it can only be set through the inherited setInfo method, and cannot directly access the name. and age attributes.
At the same time, in the Student class, we added a new private attribute id and defined public methods setId and getId for setting and getting the attribute value. Since the Student class does not expose the id attribute to the outside, its access control is private. Through inheritance, the Student class can use the methods getInfo and setInfo in the parent class to access the private attributes name and age in the parent class, thus realizing the reuse of the parent class members.
Polymorphism is another important concept in object-oriented programming. It means that the same method can accept multiple forms of parameters. , thereby achieving different behaviors. There are two ways to implement polymorphism:
In inheritance to implement polymorphism, we can Access the methods of the subclass through the reference of the parent class to achieve dynamic calling. The sample code is as follows:
public class Person {
public void say() {
System.out.println("我是人类");
}
}
public class Student extends Person {
public void say() {
System.out.println("我是学生");
}
}
public class Teacher extends Person {
public void say() {
System.out.println("我是老师");
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person();
Person student = new Student();
Person teacher = new Teacher();
person.say();
student.say();
teacher.say();
}
}The above code defines a Person class and two Student classes and Teacher classes that inherit from the Person class. In the Test class, we created a Person object, a Student object and a Teacher object respectively, and output the corresponding information by calling their say method. Since both the Student class and the Teacher class inherit from the Person class and override its say method, when the say method is called, the corresponding method will be executed according to the object type, thereby achieving a polymorphic effect.
In interface implementation polymorphism, we can define a set of methods through the interface, and then let different implementation classes implement this set of methods according to their own needs. The sample code is as follows:
public interface Animal {
public void eat();
}
public class Cat implements Animal {
public void eat() {
System.out.println("猫吃鱼");
}
}
public class Dog implements Animal {
public void eat() {
System.out.println("狗吃肉");
}
}
public class Test {
public static void main(String[] args) {
Animal cat = new Cat();
Animal dog = new Dog();
cat.eat();
dog.eat();
}
}The above code defines an Animal interface and two classes Cat and Dog that implement this interface. In the Test class, we created a Cat object and a Dog object respectively, and output the corresponding information by calling their eat method. Since both the Cat class and the Dog class implement the Animal interface and override its eat method, when the eat method is called, the corresponding method will be executed according to the object type, thus achieving a polymorphic effect.
Summarize
Through the introduction of the above logical process, we can see that object-oriented programming ideas are very important in Java development. It can help programmers better organize and manage code through encapsulation, inheritance and polymorphism, thereby improving code reusability, maintainability and scalability. For Java developers, mastering object-oriented programming ideas will be able to better achieve program development results.
The above is the detailed content of The logical process of Java development object-oriented programming (OOP). For more information, please follow other related articles on the PHP Chinese website!