今年的面试太难了？2023 年 30 个 OOP 面试问题和答案也许可以帮到你

#include <iostream>
using namespace std;

class Student{
private:
	string name;
	string surname;
	int rollNo;

public:
	Student(string studentName, string studentSurname, int studentRollNo){
		name = studentName;
		surname = studentSurname;
		rollNo = studentRollNo;
	}

	void getStudentDetails(){
		cout << "The name of the student is " << name << " " << surname << endl;
		cout << "The roll no of the student is " << rollNo << endl;
	}
};

int main() {
	Student student1("Vivek", "Yadav", 20);
	student1.getStudentDetails();

	return 0;
}

The name of the student is Vivek Yadav
The roll no of the student is 20

//封装的简单演示
//它有一个私有数据成员以及 getter 和 setter 方法。public class Student{
	//private data members
	private String name;
	private int rollNo;
//访问名称的公共获取方法
	public String getName(){
		return name;
	}
//访问 rollNo 的公共 getter 方法
	public int getRollNo(){
		return rollNo;
	}
//设置名称的公共设置方法
	public void setName(String name){
			this.name=name
	}
//设置 rollNo 的公共设置方法
	public void setRollNo(int rollNo){
			this.rollNo=rollNo;
	}
}

//implementation of abstraction through abstract class
abstract class Animal {
	abstract void walk();
	void eat()
	{
		System.out.println("The animal is eating.");
	}
	Animal()
	{
		System.out.println(
			"An Animal is going to be created.");
	}
}

class Cow extends Animal {
	Cow() { System.out.println("You have created a Cow"); }
	void walk() { System.out.println("Cow is walking."); }
}

class Goat extends Animal {
	Goat()
	{
		System.out.println("You have created a Goat");
	}
	void walk() { System.out.println("Goat is walking."); }
}

public class OOPS {
	public static void main(String args[])
	{
		Cow cow = new Cow();
		cow.walk();
		cow.eat();
		Goat goat = new Goat();
		goat.walk();
		goat.eat();
	}
}

// An example of method overloading
class Student {
String name,surname;
int rollNo;
	
public void showStudentDetails(String name) {
	System.out.println("The name of the student is " + name);
}


public void showStudentDetails(int rollNo) {
	System.out.println("the roll no of the student is "+ rollNo);
}


public void showStudentDetails(String name, String surname, int rollNo) {
	System.out.println(name);
	System.out.println(surname);
	System.out.println(age);
}
}

// 方法规避的一个例子
class Student {
public void read() {
	System.out.println("The student is reading");
}
}
class SchoolStudent extends Student {
public void read(String book) {
	System.out.println("the student is reding "+ book);
}
}
class CollegeStudent extends Student {
public void read(String researchPaper , String labJournal) {
	System.out.println("the student is reading "+researchPaper +" and "+ labJournal);
}
}

// 继承的一个例子
class Student {
public void read() {
	System.out.println("The student is reading");
}
}
class SchoolStudent extends Student {
public void read(String book) {
	System.out.println("the student is reding "+ book);
}
}

class User {
public String userName;
protected String userEmail;
private String password;


public void setPassword(String password) {
	this.password = password;
}
}
public class OOPS {
public static void main(String args[]) {
	User user1 = new User();
	user1.userName = "Vivek_Kumar_Yadav";
	user1.setPassword("abcd@12345");
	user1.userEmail = "abc@gmail.com";
}
}

// 单继承的一个例子
class Father {
// 父亲的任何特定属性和功能
}
class Son extends Father {
//继承了父类的属性和函数
}

// 一个层次继承的示例
class Father {
// 任何特定于父亲的属性和函数
}
class Son extends Father {
//继承了父类的属性和函数
}
class Daughter extends Father {
//继承了父类的属性和函数
}

// 多级继承的一个例子
class Father {
// 父亲的任何特定属性和功能
}
class Son extends Father {
//继承父亲的属性和功能
}
class GrandChild extends Son {
	
}

class Student {
	String name;
	String surname;
	int rollNo;
	Student()
	{
		cout<< "contructor is called";
	}
}

class Student {
	String name;
	String surname;
	int rollNo;
	Student()
	{
		System.out.println("contructor is called");
	}
}

class base:
	def __init__(self):
		print("This is a constructor")

class Student {
	String name;
	String surname;
	int rollNo;
	Student()
	{
		cout << "Non-parameterized contructor is called" ;
	}
}

class Student {
	String name;
	String surname;
	int rollNo;
	Student()
	{
		System.out.println("Non-parameterized contructor is called");
	}
}

class base:
	def __init__(self):
		print("This is a non-parameterized constructor")

class Student {
	String name;
	String surname;
	int rollNo;
	Student(String studentName, String studentSurname, int studentRollNo)
	{
		cout << "Constructor with argument is called";
	}
}

class Student {
	String name;
	String surname;
	int rollNo;
	Student(String studentName, String studentSurname, int studentRollNo)
	{
		System.out.println("Constructor with argument is called");
	}
}

class base:
	def __init__(self, a):
		print("Constructor with argument: {}".format(a))

class Student {
	String name, surname; int rollNo;
	Student(Student& student) // copy constructor
	{
		name = student.name;
		surname=student.surname;
		rollNo= student.rollNo;
	}
}

class Student {
	String name, surname; int rollNo;
	Student(Student student) // copy constructor
	{
		this.name = student.name;
		this.surname=student.surname;
		this.rollNo= student.rollNo;
	}
}

class base {
public:
	~base() { cout << "This is a destructor"; }
}

class base:
	def __del__(self):
		print("This is destructor")

class base {
	virtual void print()
	{
		cout << "This is a virtual function";
	}
}

class base {
	void func()
	{
		System.out.printIn("This is a virtual function")
	}
}

class base:
	def func(self):
		print("This is a virtual function")

class base {
	virtual void pureVirFunc() = 0;
}

abstract class base {
	abstract void prVirFunc();
}