ಸ್ಥಾಯೀ ಸದಸ್ಯರು ಮತ್ತು ಸ್ಥಿರ ಪರಿವರ್ತಕ. ಜಾವಾ: ಸ್ಥಿರ ವಿಧಾನಗಳನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು

ನೀವು ಕೆಲವು ವರ್ಗ ವಿಧಾನಗಳನ್ನು ಸ್ಥಿರ ವಿಧಾನಗಳಾಗಿ ಘೋಷಿಸಬಹುದು. ಇದನ್ನು ಮಾಡಲು ನೀವು ಸ್ಥಿರ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬೇಕು. ಸ್ಥಿರ ವಿಧಾನಗಳು ಈ ನಿಯತಾಂಕವನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ. ಸ್ಥಿರ ವಿಧಾನಗಳ ಬಳಕೆಯ ಮೇಲೆ ಹಲವಾರು ನಿರ್ಬಂಧಗಳಿವೆ.

ಸ್ಥಿರ ವಿಧಾನಗಳು ವರ್ಗದ ಸ್ಥಿರ ಸದಸ್ಯರನ್ನು ಮಾತ್ರ ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು.

ಸ್ಥಿರ ವಿಧಾನವನ್ನು ವರ್ಚುವಲ್ ವಿಧಾನವೆಂದು ಘೋಷಿಸಲಾಗುವುದಿಲ್ಲ.

ನೀವು ಸ್ಥಿರವಲ್ಲದ ವಿಧಾನವನ್ನು ಅದೇ ಹೆಸರಿನೊಂದಿಗೆ ಮತ್ತು ಅದೇ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಸೆಟ್ ಅನ್ನು ಸ್ಥಿರ ವರ್ಗ ವಿಧಾನವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಸ್ಥಿರ ವಿಧಾನಗಳು ಒಂದು ಆಸಕ್ತಿದಾಯಕ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊಂದಿವೆ - ವರ್ಗದ ವಸ್ತುಗಳನ್ನು ರಚಿಸದೆಯೇ ನೀವು ಅವುಗಳನ್ನು ಕರೆಯಬಹುದು. ಪ್ರೋಗ್ರಾಂನಿಂದ ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಕರೆಯಲು, ನೀವು ಅದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು ಪೂರ್ಣ ಹೆಸರು, ವರ್ಗದ ಹೆಸರು ಸೇರಿದಂತೆ.

ಕೆಳಗೆ ಸರ್ಕಲ್ ವರ್ಗ, ಇದು ಸ್ಥಿರ GetPi ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. fPi ವರ್ಗದ ಸ್ಥಿರ ಸದಸ್ಯರ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಸ್ಥಿರ ಶೂನ್ಯ GetPi()

ಸ್ಥಿರ ಫ್ಲೋಟ್ fPi;

ಫ್ಲೋಟ್ ಸರ್ಕಲ್ :: fPi = 3.1415;

ನೀವು GetPi ವಿಧಾನವನ್ನು ಈ ರೀತಿ ಕರೆಯಬಹುದು:

fNumber = ವೃತ್ತ ::GetPi();

ಸರ್ಕಲ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಲಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

ವರ್ಗ ವಸ್ತುಗಳ ಸಾಮಾನ್ಯ ಸದಸ್ಯರು

ನಿರ್ದಿಷ್ಟ ವರ್ಗದ ಎಲ್ಲಾ ವಸ್ತುಗಳು ಹೊಂದಲು ಕೆಲವೊಮ್ಮೆ ಇದು ಅನುಕೂಲಕರವಾಗಿರುತ್ತದೆ ಸಾಮಾನ್ಯ ಅಂಶಗಳುಹಂಚಿಕೊಳ್ಳಲಾದ ಡೇಟಾ. ಈ ಕಾರಣದಿಂದಾಗಿ, ನೀವು ಜಾಗತಿಕ ಅಸ್ಥಿರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು, ಪ್ರೋಗ್ರಾಂನ ರಚನೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.

ಹಂಚಿದ ವರ್ಗ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಸ್ಥಿರ ಕೀವರ್ಡ್‌ನೊಂದಿಗೆ ಘೋಷಿಸಬೇಕು. ವರ್ಗದ ಎಲ್ಲಾ ಸಾಮಾನ್ಯ ಅಂಶಗಳನ್ನು ಪ್ರೋಗ್ರಾಂ ಪಠ್ಯದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು, ಅವರಿಗೆ RAM ನಲ್ಲಿ ಜಾಗವನ್ನು ಕಾಯ್ದಿರಿಸಬೇಕು:

ಸಾರ್ವಜನಿಕ

Cwindow ವರ್ಗದ ಪ್ರತಿಯೊಂದು ವಸ್ತುವು ವಿಶಿಷ್ಟ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇದನ್ನು xLeftTop, xRightBottom, yLeftTop, yRightBottom ಡೇಟಾ ಅಂಶಗಳಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಶೀರ್ಷಿಕೆ ಡೇಟಾ ಅಂಶದಿಂದ ಸಂಗ್ರಹಿಸಲಾದ ಅದೇ ಶೀರ್ಷಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಸಾಮಾನ್ಯ ಡೇಟಾ ಸದಸ್ಯರು ಅವರ ವರ್ಗದ ವ್ಯಾಪ್ತಿಯಲ್ಲಿರುತ್ತಾರೆ. ವರ್ಗ ವಿಧಾನಗಳು ವರ್ಗದಿಂದ ಇತರ ಡೇಟಾದ ರೀತಿಯಲ್ಲಿಯೇ ಹಂಚಿಕೊಂಡ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

ಅನೂರ್ಜಿತ SetTitle(char* sSource)

(strcpy(ಶೀರ್ಷಿಕೆ, ಮೂಲ);)

ಪ್ರೋಗ್ರಾಂನಿಂದ ಸಾರ್ವಜನಿಕ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು, ನೀವು ಅವುಗಳನ್ನು ಸಾರ್ವಜನಿಕ ಎಂದು ಘೋಷಿಸಬೇಕು. ಅಂತಹ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು, ನೀವು ಅದರ ಹೆಸರನ್ನು ವರ್ಗದ ಹೆಸರು ಮತ್ತು :: ಆಪರೇಟರ್‌ನೊಂದಿಗೆ ಮುಂಚಿತವಾಗಿ ನಮೂದಿಸಬೇಕು.

printf(Cwindow::title);

ಸೌಹಾರ್ದ ಕಾರ್ಯಗಳು ಮತ್ತು ಸೌಹಾರ್ದ ತರಗತಿಗಳು

ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಇತರ ತರಗತಿಗಳಿಂದ ವರ್ಗ ಅಂಶಗಳಿಗೆ ಪ್ರವೇಶ ಸೀಮಿತವಾಗಿದೆ. ಸಾರ್ವಜನಿಕ ಕೀವರ್ಡ್ ನಂತರ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಅಥವಾ ಘೋಷಿಸಲಾದ ವರ್ಗದ ಸದಸ್ಯರನ್ನು ಮಾತ್ರ ನೀವು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ವರ್ಗದ ಹೊರಗಿನ ಕಾರ್ಯವನ್ನು ಅಥವಾ ಇನ್ನೊಂದು ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಅವಶ್ಯಕವಾಗಿದೆ, ಅದರ ವಿಧಾನಗಳು ಖಾಸಗಿ ಮತ್ತು ರಕ್ಷಿಸುವ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ವರ್ಗದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು.

ಸ್ನೇಹಪರ ವೈಶಿಷ್ಟ್ಯಗಳು

C++ ನಲ್ಲಿ, ಫ್ರೆಂಡ್ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ವರ್ಗಕ್ಕೆ ಸ್ನೇಹಿತರ ಕಾರ್ಯ ಎಂದು ಕರೆಯಲ್ಪಡುವದನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ವರ್ಗವು ಸ್ನೇಹಿತರ ಕಾರ್ಯದ ಘೋಷಣೆಯನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ. ಇದರ ವ್ಯಾಖ್ಯಾನವು ವರ್ಗದ ಹೊರಗೆ ಇದೆ. ನೀವು ವರ್ಗದ ಯಾವುದೇ ವಿಭಾಗದಲ್ಲಿ ಸ್ನೇಹಿತರ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಬಹುದು - ಸಾರ್ವಜನಿಕ, ಖಾಸಗಿ, ಅಥವಾ ರಕ್ಷಿಸಿ.

ಸ್ನೇಹಿತರ ಕಾರ್ಯವು ವರ್ಗದ ಸದಸ್ಯರಲ್ಲ, ಆದರೆ ಖಾಸಗಿ ಮತ್ತು ರಕ್ಷಣೆ ಸೇರಿದಂತೆ ಅದರ ಎಲ್ಲಾ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಒಂದೇ ಕಾರ್ಯವು ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ವರ್ಗಗಳಿಗೆ ಸ್ನೇಹಿಯಾಗಿರಬಹುದು.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಪಾಯಿಂಟ್ ವರ್ಗಕ್ಕೆ ಸ್ನೇಹಿಯಾಗಿರುವ ಕ್ಲಿಯರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಖಾಸಗಿ ಎಂದು ಘೋಷಿಸಲಾದ ಡೇಟಾ ಸದಸ್ಯರ m_x ಮತ್ತು m_y ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು ಸ್ನೇಹಪರ ಕಾರ್ಯವನ್ನು ತೆರವುಗೊಳಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ:

// ಪಾಯಿಂಟ್ ವರ್ಗ

// ಕ್ಲಿಯರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಪಾಯಿಂಟ್ ವರ್ಗಕ್ಕೆ ಸ್ನೇಹಿ ಎಂದು ಘೋಷಿಸಲಾಗಿದೆ

ಸ್ನೇಹಿತ ನಿರರ್ಥಕ ಬಿಂದು:: ಕ್ಲಿಯರ್(ಪಾಯಿಂಟ್*);

// ವರ್ಗ ಇಂಟರ್ಫೇಸ್...

//==========================================================

// ಕಾರ್ಯವನ್ನು ತೆರವುಗೊಳಿಸಿ

ನಿರರ್ಥಕ ತೆರವುಗೊಳಿಸಿ (ಪಾಯಿಂಟ್* ptrPoint)

// ಪ್ರವೇಶ ವರ್ಗ ಅಂಶಗಳನ್ನು ಖಾಸಗಿ ಎಂದು ಘೋಷಿಸಲಾಗಿದೆ

ptrPoint->m_x = 0;

ptrPoint->m_y = 0;

//==========================================================

// ಮುಖ್ಯ ಕಾರ್ಯ

ಪಾಯಿಂಟ್ ಪಾಯಿಂಟ್ ಟೆಸ್ಟ್ಪಾಯಿಂಟ್;

// ಸೌಹಾರ್ದ ಕಾರ್ಯಕ್ಕೆ ಕರೆ ಮಾಡಿ

ತೆರವುಗೊಳಿಸಿ(&pointTestPoint);

ಸ್ನೇಹಿತ ಕೀವರ್ಡ್ ಸಹಾಯದಿಂದ, ನೀವು ಒಂದು ವರ್ಗದ ಕೆಲವು ವಿಧಾನಗಳನ್ನು ಇನ್ನೊಂದು ವರ್ಗದ ಸ್ನೇಹಿತರಾಗಿ ಘೋಷಿಸಬಹುದು. ಅಂತಹ ವಿಧಾನಗಳು ಒಂದು ವರ್ಗದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು, ಖಾಸಗಿಯಾಗಿ ಘೋಷಿಸಲ್ಪಟ್ಟವುಗಳು ಮತ್ತು ರಕ್ಷಿಸುತ್ತವೆ, ಅವುಗಳು ಸ್ವತಃ ಮತ್ತೊಂದು ವರ್ಗದ ಭಾಗವಾಗಿದ್ದರೂ ಸಹ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಎರಡು ವರ್ಗಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ - ಲೈನ್ ಮತ್ತು ಪಾಯಿಂಟ್. ಪಾಯಿಂಟ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ನಾವು ಸೆಟ್ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಲೈನ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಸ್ನೇಹಪರವೆಂದು ಘೋಷಿಸುತ್ತೇವೆ. ಸ್ನೇಹಿ ಸೆಟ್ ವಿಧಾನವು ಸಾಲಿನ ವರ್ಗದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

// ಸಾಲಿನ ವರ್ಗದ ಪೂರ್ವ ಘೋಷಣೆ

//==========================================================

// ಪಾಯಿಂಟ್ ವರ್ಗ

// ಪಾಯಿಂಟ್ ವರ್ಗದ ವಿಧಾನವನ್ನು ಹೊಂದಿಸಿ

ಅನೂರ್ಜಿತ ಸೆಟ್ (ಲೈನ್*);

//==========================================================

// ವರ್ಗ ಸಾಲು

// ಪಾಯಿಂಟ್ ವರ್ಗದ ಸೆಟ್ ವಿಧಾನವನ್ನು ಸ್ನೇಹಿ ಎಂದು ಘೋಷಿಸಲಾಗಿದೆ

// ವರ್ಗ ಪಾಯಿಂಟ್

ಸ್ನೇಹಿತ ಅನೂರ್ಜಿತ ಬಿಂದು :: ಸೆಟ್ (ಲೈನ್*);

ಇಂಟ್ ಬಿಗ್_ಎಕ್ಸ್, ಬಿಗ್_ವೈ;

int end_x, end_y;

//==========================================================

// ಕಾರ್ಯವನ್ನು ತೆರವುಗೊಳಿಸಿ

ಅನೂರ್ಜಿತ ಬಿಂದು:: ಹೊಂದಿಸಿ(ಲೈನ್* ptrLine)

// ಸಾಲಿನ ವರ್ಗದ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಿ, ಎಂದು ಘೋಷಿಸಲಾಗಿದೆ

ptrLine->begin_x = 0;

ptrLine->begin_y = 0;

//==========================================================

// ಮುಖ್ಯ ಕಾರ್ಯ

ಪಾಯಿಂಟ್ ಪಾಯಿಂಟ್ ಟೆಸ್ಟ್ಪಾಯಿಂಟ್;

ಲೈನ್ ಲೈನ್ ಟೆಸ್ಟ್ಪಾಯಿಂಟ್;

// ಸ್ನೇಹಿ ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿ

pointTestPoint.Set(&lineTestPoint);

ಕೊನೆಯ ನವೀಕರಣ: 04/19/2018

ನಿಯಮಿತ ವಿಧಾನಗಳು ಮತ್ತು ಕ್ಷೇತ್ರಗಳ ಜೊತೆಗೆ, ಒಂದು ವರ್ಗವು ಸ್ಥಿರ ಕ್ಷೇತ್ರಗಳು, ವಿಧಾನಗಳು, ಸ್ಥಿರಾಂಕಗಳು ಮತ್ತು ಇನಿಶಿಯಲೈಸರ್ಗಳನ್ನು ಹೊಂದಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರೋಗ್ರಾಂನ ಮುಖ್ಯ ವರ್ಗವು ಮುಖ್ಯ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ, ಅದು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ:

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ನಿರರ್ಥಕ ಮುಖ್ಯ (ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) ( )

ಸ್ಥಿರ ಅಸ್ಥಿರಗಳು, ಸ್ಥಿರಾಂಕಗಳು, ವಿಧಾನಗಳು ಮತ್ತು ಇನಿಶಿಯಲೈಜರ್‌ಗಳನ್ನು ಘೋಷಿಸಲು, ಅವುಗಳ ಘೋಷಣೆಯ ಮೊದಲು ಕೀಲಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ ಸ್ಥಿರ ಪದ.

ಸ್ಥಿರ ಕ್ಷೇತ್ರಗಳು

ವರ್ಗ ವಸ್ತುಗಳನ್ನು ರಚಿಸಿದಾಗ, ಪ್ರತಿ ವಸ್ತುವು ಸ್ಥಿರವಲ್ಲದ ನಿಯಮಿತ ಕ್ಷೇತ್ರಗಳ ತನ್ನದೇ ಆದ ನಕಲನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಮತ್ತು ಸ್ಥಿರ ಕ್ಷೇತ್ರಗಳು ಇಡೀ ವರ್ಗಕ್ಕೆ ಸಾಮಾನ್ಯವಾಗಿದೆ. ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ವರ್ಗ ವಸ್ತುಗಳನ್ನು ರಚಿಸದೆ ಬಳಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಅನ್ನು ರಚಿಸೋಣ:

ಸಾರ್ವಜನಿಕ ವರ್ಗ ಕಾರ್ಯಕ್ರಮ(ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) (ಪರ್ಸನ್ ಟಾಮ್ = ಹೊಸ ವ್ಯಕ್ತಿ(); ವ್ಯಕ್ತಿ ಬಾಬ್ = ಹೊಸ ವ್ಯಕ್ತಿ(); tom.displayId(); // Id = 1 bob.displayId(); // Id = 2 System.out.println(Person.counter); // 3 // Person.counter ವ್ಯಕ್ತಿ.ಕೌಂಟರ್ = 8 ಕೌಂಟರ್ = 1

ವ್ಯಕ್ತಿ ವರ್ಗವು ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಕೌಂಟರ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಕನ್ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ಹೆಚ್ಚಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ಐಡಿ ವೇರಿಯಬಲ್‌ಗೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಅಂದರೆ, ಪ್ರತಿ ಹೊಸ ವ್ಯಕ್ತಿ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವಾಗ, ಈ ವೇರಿಯೇಬಲ್ ಹೆಚ್ಚಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಪ್ರತಿ ಹೊಸ ವ್ಯಕ್ತಿ ಆಬ್ಜೆಕ್ಟ್ ಹಿಂದಿನದಕ್ಕಿಂತ 1 ಹೆಚ್ಚಿನ ಐಡಿ ಕ್ಷೇತ್ರ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಕೌಂಟರ್ ವೇರಿಯೇಬಲ್ ಸ್ಥಿರವಾಗಿರುವುದರಿಂದ, ನಾವು ಅದನ್ನು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಅದರ ವರ್ಗ ಹೆಸರಿನಿಂದ ಉಲ್ಲೇಖಿಸಬಹುದು:

System.out.println(Person.counter); // ಮೌಲ್ಯವನ್ನು ಪಡೆಯಿರಿ Person.counter = 8; // ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿ

ಕಾರ್ಯಕ್ರಮದ ಕನ್ಸೋಲ್ ಔಟ್‌ಪುಟ್:

ಐಡಿ = 1 ಐಡಿ = 2 3 ಐಡಿ = 8

ಸ್ಥಿರ ಸ್ಥಿರಾಂಕಗಳು

ಸ್ಥಾಯಿಯು ಸಂಪೂರ್ಣ ವರ್ಗಕ್ಕೆ ಸಾಮಾನ್ಯವಾಗಿರುವ ಸ್ಥಿರಾಂಕಗಳಾಗಿವೆ.

ಪಬ್ಲಿಕ್ ಕ್ಲಾಸ್ ಪ್ರೋಗ್ರಾಂ(ಸಾರ್ವಜನಿಕ ಸ್ಟ್ಯಾಟಿಕ್ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) ( ಡಬಲ್ ತ್ರಿಜ್ಯ = 60; System.out.printf("Radisu: %f \n", ತ್ರಿಜ್ಯ); // 60 System.out.printf("ಪ್ರದೇಶ: %f \n", Math.PI * ತ್ರಿಜ್ಯ); // 188.4 ) ) ವರ್ಗ ಗಣಿತ(ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಅಂತಿಮಡಬಲ್ ಪಿಐ = 3.14; )

ಹಿಂದಿನ ಎಲ್ಲಾ ವಿಷಯಗಳ ಉದ್ದಕ್ಕೂ, ಸ್ಥಿರ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಈಗಾಗಲೇ ಸಕ್ರಿಯವಾಗಿ ಬಳಸಲಾಗಿದೆ ಎಂದು ಗಮನಿಸಬೇಕಾದ ಅಂಶವಾಗಿದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ:

System.out.println("ಹಲೋ");

ಔಟ್ ಕೇವಲ ಸಿಸ್ಟಮ್ ವರ್ಗದ ಸ್ಥಿರ ಸ್ಥಿರಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸಿಸ್ಟಮ್ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸದೆಯೇ ಇದನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ.

ಸ್ಥಾಯೀ ಇನಿಶಿಯಲೈಜರ್‌ಗಳು

ಸ್ಟ್ಯಾಟಿಕ್ ಇನಿಶಿಯಲೈಜರ್‌ಗಳನ್ನು ಸ್ಥಾಯೀ ಅಸ್ಥಿರಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅಥವಾ ಮೊದಲ ವಸ್ತುವನ್ನು ರಚಿಸಿದಾಗ ನಿರ್ವಹಿಸುವ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಸ್ಥಿರ ಇನಿಶಿಯಲೈಜರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ:

ಸಾರ್ವಜನಿಕ ವರ್ಗ ಕಾರ್ಯಕ್ರಮ(ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) (ಪರ್ಸನ್ ಟಾಮ್ = ಹೊಸ ವ್ಯಕ್ತಿ(); ವ್ಯಕ್ತಿ ಬಾಬ್ = ಹೊಸ ವ್ಯಕ್ತಿ(); tom.displayId(); // Id = 105 bob.displayId(); // Id = 106 ) ) ವರ್ಗದ ವ್ಯಕ್ತಿ(ಖಾಸಗಿ ಇಂಟ್ ಐಡಿ; ಸ್ಟ್ಯಾಟಿಕ್ ಇಂಟ್ ಕೌಂಟರ್; ಸ್ಟಾಟಿಕ್( ಕೌಂಟರ್ = 105; System.out.println("ಸ್ಟಾಟಿಕ್ ಇನಿಶಿಯಲೈಜರ್"); ) ವ್ಯಕ್ತಿ())( id=counter++; System.out.println("ಕನ್ಸ್ಟ್ರಕ್ಟರ್ "); ) ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಡಿಸ್ಪ್ಲೇ Id())( System.out.printf("Id: %d \n", id); ) )

ಸ್ಥಾಯೀ ಇನಿಶಿಯಲೈಸರ್ ಅನ್ನು ನಿಯಮಿತ ಇನಿಶಿಯಲೈಜರ್ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಅದರ ಮೊದಲು ಮಾತ್ರ ಕೀವರ್ಡ್ಸ್ಥಿರ. IN ಈ ಸಂದರ್ಭದಲ್ಲಿಸ್ಟ್ಯಾಟಿಕ್ ಇನಿಶಿಯಲೈಜರ್‌ನಲ್ಲಿ ನಾವು ಸ್ಟ್ಯಾಟಿಕ್ ಫೀಲ್ಡ್ ಕೌಂಟರ್‌ನ ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ ಮತ್ತು ಕನ್ಸೋಲ್‌ಗೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತೇವೆ.

ಪ್ರೋಗ್ರಾಂನಲ್ಲಿಯೇ, ವ್ಯಕ್ತಿ ವರ್ಗದ ಎರಡು ವಸ್ತುಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ, ಕನ್ಸೋಲ್ ಔಟ್ಪುಟ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಸ್ಟ್ಯಾಟಿಕ್ ಇನಿಶಿಯಲೈಸರ್ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಐಡಿ: 105 ಐಡಿ: 106

ಮೊದಲ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸುವ ಮೊದಲು ಮಾತ್ರ ಸ್ಥಾಯೀ ಇನಿಶಿಯಲೈಜರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಎಂದು ಪರಿಗಣಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ.

ಸ್ಥಿರ ವಿಧಾನಗಳು

ಸ್ಥಿರ ವಿಧಾನಗಳು ಒಟ್ಟಾರೆಯಾಗಿ ಇಡೀ ವರ್ಗಕ್ಕೆ ಅನ್ವಯಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಕೌಂಟರ್ ಅನ್ನು ಬಾಹ್ಯವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ನಾವು ಅದರ ಮೌಲ್ಯವನ್ನು ವ್ಯಕ್ತಿ ವರ್ಗದ ಹೊರಗೆ ಬದಲಾಯಿಸಬಹುದು. ಅದನ್ನು ಹೊರಗಿನಿಂದ ಬದಲಾಯಿಸಲಾಗದಂತೆ ಮಾಡೋಣ, ಆದರೆ ಓದಬಲ್ಲದು. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ:

ಸಾರ್ವಜನಿಕ ವರ್ಗ ಕಾರ್ಯಕ್ರಮ(ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) (Person.displayCounter(); // ಕೌಂಟರ್: 1 ವ್ಯಕ್ತಿ ಟಾಮ್ = ಹೊಸ ವ್ಯಕ್ತಿ(); ವ್ಯಕ್ತಿ ಬಾಬ್ = ಹೊಸ ವ್ಯಕ್ತಿ(); Person.displayCounter(); // ಕೌಂಟರ್: 3 ) ) ವರ್ಗದ ವ್ಯಕ್ತಿ(ಖಾಸಗಿ ಇಂಟ್ ಐಡಿ; ಖಾಸಗಿ ಸ್ಟ್ಯಾಟಿಕ್ ಇಂಟ್ ಕೌಂಟರ್ = 1; ವ್ಯಕ್ತಿ())(ಐಡಿ = ಕೌಂಟರ್++; ) // ಸ್ಥಿರ ವಿಧಾನ ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಶೂನ್ಯ ಡಿಸ್ಪ್ಲೇಕೌಂಟರ್())( System.out.printf("ಕೌಂಟರ್: %d \n ", ಕೌಂಟರ್); ) ಸಾರ್ವಜನಿಕ ಅನೂರ್ಜಿತ ಪ್ರದರ್ಶನ Id())( System.out.printf("Id: %d \n", id); ) )

ಈಗ ಸ್ಥಿರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹೊರಗಿನಿಂದ ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ, ಅದು ಖಾಸಗಿಯಾಗಿದೆ. ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ಸ್ಥಿರ ಪ್ರದರ್ಶನ ಕೌಂಟರ್ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಕರೆಯಲು, ವರ್ಗದ ಹೆಸರನ್ನು ಬಳಸಿ: Person.displayCounter() .

ಸ್ಥಿರ ವಿಧಾನಗಳನ್ನು ಬಳಸುವಾಗ, ನಾವು ನಿರ್ಬಂಧಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು: ಸ್ಥಿರ ವಿಧಾನಗಳಲ್ಲಿ, ನಾವು ಇತರ ಸ್ಥಿರ ವಿಧಾನಗಳನ್ನು ಮಾತ್ರ ಕರೆಯಬಹುದು ಮತ್ತು ಸ್ಥಿರ ಅಸ್ಥಿರಗಳನ್ನು ಮಾತ್ರ ಬಳಸಬಹುದು.

ಸಾಮಾನ್ಯವಾಗಿ, ವಿಧಾನಗಳು ವಸ್ತುವಿನ ಸ್ಥಿತಿಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದಿದ್ದಾಗ ವಿಧಾನಗಳನ್ನು ಸ್ಥಿರವೆಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಅದರ ಸ್ಥಿರವಲ್ಲದ ಕ್ಷೇತ್ರಗಳು ಮತ್ತು ಸ್ಥಿರಾಂಕಗಳು, ಮತ್ತು ವಿಧಾನವನ್ನು ಕರೆಯಲು ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ರಚಿಸುವಲ್ಲಿ ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ. ಉದಾಹರಣೆಗೆ:

ಪಬ್ಲಿಕ್ ಕ್ಲಾಸ್ ಪ್ರೋಗ್ರಾಂ(ಸಾರ್ವಜನಿಕ ಸ್ಟ್ಯಾಟಿಕ್ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) ( System.out.println(Operation.sum(45, 23)); // 68 System.out.println(Operation.subtract(45, 23)); // 22 System.out.println(Operation.multiply(4, 23)); ವರ್ಗ ಕಾರ್ಯಾಚರಣೆ(ಸ್ಥಿರ ಇಂಟ್ ಮೊತ್ತ(ಇಂಟ್ x, ಇಂಟ್ ವೈ)( ರಿಟರ್ನ್ x + ವೈ; )( ಹಿಂತಿರುಗಿ x - y; ) ಸ್ಥಿರ ಇಂಟ್ ಗುಣಿಸಿ (int x, int y)( ಹಿಂತಿರುಗಿ x * y; ) )

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಧಾನಗಳ ಮೊತ್ತ, ಕಳೆಯಿರಿ, ಗುಣಿಸಿ, ಕಾರ್ಯಾಚರಣೆ ವರ್ಗದ ಯಾವ ನಿದರ್ಶನವನ್ನು ಬಳಸಲಾಗಿದೆ ಎಂಬುದು ಮುಖ್ಯವಲ್ಲ. ಈ ವಿಧಾನಗಳು ವರ್ಗದ ಸ್ಥಿತಿಯನ್ನು ಬಾಧಿಸದೆ, ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಆದ್ದರಿಂದ, ಅವುಗಳನ್ನು ಸ್ಥಿರ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

ವಿಧಾನದ ನಿಯತಾಂಕಗಳ ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆ

ಕೆಲವೊಮ್ಮೆ ಒಂದು ವಿಧಾನಕ್ಕೆ ರವಾನಿಸಲಾಗುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಸಂಖ್ಯೆಯು ರನ್‌ಟೈಮ್‌ವರೆಗೆ ತಿಳಿದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, x- ಮತ್ತು y- ನಿರ್ದೇಶಾಂಕಗಳ ಅನುಕ್ರಮವನ್ನು ನೀಡಿದ ಗ್ರಾಫ್‌ನಲ್ಲಿ ರೇಖೆಯನ್ನು ಎಳೆಯುವ ವರ್ಗ ನಿಮಗೆ ಬೇಕಾಗುತ್ತದೆ. ಈ ವರ್ಗವು ಒಂದೇ ವಾದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ವಿಧಾನವನ್ನು ಒಳಗೊಂಡಿರಬೇಕು - ಪ್ರಕಾರದ ವಸ್ತು ಪಾಯಿಂಟ್, x ಮತ್ತು y ಎರಡೂ ನಿರ್ದೇಶಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಪ್ರಕಾರದ ಪ್ರತಿಯೊಂದು ವಸ್ತುವನ್ನು ಉಳಿಸಬೇಕು ಪಾಯಿಂಟ್ಲಿಂಕ್ ಮಾಡಲಾದ ಪಟ್ಟಿಯಲ್ಲಿ ಅಥವಾ ಅರೇ ಅಂಶಗಳಲ್ಲಿ ಕರೆ ಮಾಡುವ ಪ್ರೋಗ್ರಾಂ ಅಂಕಗಳ ಸಂಪೂರ್ಣ ಅನುಕ್ರಮವನ್ನು ಮುದ್ರಿಸಲು ಆದೇಶಿಸುವವರೆಗೆ. ಆದಾಗ್ಯೂ, ಈ ಪರಿಹಾರವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ಉಪಸ್ಥಿತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿ. ಆದರೆ ಅದನ್ನು ಬಳಸಬಹುದಿತ್ತು ಏಕೈಕ ವಿಧಾನ - ಡ್ರಾಲೈನ್ಯಾರಿಗೆ ಈ ಪಟ್ಟಿ ಅಗತ್ಯವಿಲ್ಲದಿರಬಹುದು . ಈ ಸಮಸ್ಯೆಯನ್ನು ವೇರಿಯಬಲ್-ಆರ್ಗ್ಯುಮೆಂಟ್ ವಿಧಾನದಿಂದ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ.

ಈ ವಿಧಾನವನ್ನು ಹೊಂದಿಸಬಹುದು ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಕೀವರ್ಡ್ ಮೂಲಕ ವಾದಗಳು ನಿಯತಾಂಕಗಳುರಚನೆಯ ರೂಪದಲ್ಲಿ. ಉದಾಹರಣೆ ವರ್ಗವನ್ನು ನೋಡೋಣ ಚಾರ್ಟ್, C# ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ, ಒಂದು ಕರೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ಔಟ್‌ಪುಟ್ ಮಾಡಲು ಬಳಕೆದಾರರಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ ಅನಿಯಂತ್ರಿತ ಸಂಖ್ಯೆವಸ್ತುಗಳು ಪಾಯಿಂಟ್:

ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸುವುದು;

ಕ್ಲಾಸ್ ಪಾಯಿಂಟ್ //ಪಾಯಿಂಟ್ ಕ್ಲಾಸ್

ಸಾರ್ವಜನಿಕ ಪಾಯಿಂಟ್ (ಇಂಟ್ x, ಇಂಟ್ ವೈ) (ಇದು.x = x; this.y = y; )

ಸಾರ್ವಜನಿಕ ಇಂಟ್ x; ಸಾರ್ವಜನಿಕ ಇಂಟ್ ವೈ;

ವರ್ಗ ಚಾರ್ಟ್ // ಡ್ರಾಯರ್ ವರ್ಗ

ಸಾರ್ವಜನಿಕ ಶೂನ್ಯ ಡ್ರಾಲೈನ್ (ಗ್ರಾಫಿಕ್ಸ್ ಜಿ, ಪ್ಯಾರಮ್ಸ್ ಪಾಯಿಂಟ್ ಪಿ)

Console.WriteLine("\nಈ ವಿಧಾನವು " + ಗೆರೆಯನ್ನು ಸೆಳೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ

"ಮೂಲಕ ಮುಂದಿನ ಅಂಕಗಳು:");

ಗಾಗಿ (int i = 0; i< p.GetLength(0); i++)

( Console.WriteLine("(0), (1)". p[i].x, p[i].y); )

ವರ್ಗ ChartApp

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ()

ಪಾಯಿಂಟ್ p1 = ಹೊಸ ಪಾಯಿಂಟ್(5,10);

ಪಾಯಿಂಟ್ p2 = ಹೊಸ ಪಾಯಿಂಟ್(5, 15);

ಪಾಯಿಂಟ್ p3 = ಹೊಸ ಪಾಯಿಂಟ್(5, 20);

ಚಾರ್ಟ್ ಚಾರ್ಟ್ = ಹೊಸ ಚಾರ್ಟ್();

chart.DrawLine(p1, p2, p3);

ವಿಧಾನ ಡ್ರಾಲೈನ್ C# ಕಂಪೈಲರ್‌ಗೆ ಅದು ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ವಸ್ತುಗಳ ಪ್ರಕಾರವನ್ನು ಸ್ವೀಕರಿಸಬಹುದು ಎಂದು ಹೇಳುತ್ತದೆ ಪಾಯಿಂಟ್.ನಂತರ ರನ್ಟೈಮ್ನಲ್ಲಿ ವಿಧಾನವು ಸರಳ ಲೂಪ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಫಾರ್ಎಲ್ಲಾ ವಸ್ತುಗಳ ಮೂಲಕ ಹೋಗಲು ಪಾಯಿಂಟ್ಮತ್ತು ಎಲ್ಲಾ ಅಂಕಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಸ್ಥಿರ ವಿಧಾನವು ವರ್ಗದಲ್ಲಿ ಇರುವ ಒಂದು ವಿಧಾನವಾಗಿದೆ, ಮತ್ತು ಅದರ ಪ್ರತ್ಯೇಕ ನಿದರ್ಶನಗಳಲ್ಲಿ ಅಲ್ಲ. ಇತರ ಸ್ಥಿರ ಸದಸ್ಯರಂತೆ, ಸ್ಥಾಯೀ ವಿಧಾನಗಳ ಮುಖ್ಯ ಪ್ರಯೋಜನವೆಂದರೆ ಅವುಗಳು ಕ್ಲಾಸ್ನ ಕಾಂಕ್ರೀಟ್ ನಿದರ್ಶನಗಳ ಹೊರಗೆ, ಅಡಚಣೆಯಿಲ್ಲದೆ ನೆಲೆಗೊಂಡಿವೆ. ಜಾಗತಿಕ ಜಾಗಅಪ್ಲಿಕೇಶನ್ಗಳು. ಅದೇ ಸಮಯದಲ್ಲಿ, ಅವರು OOP ಯ ತತ್ವಗಳನ್ನು ಉಲ್ಲಂಘಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಅವರು ನಿರ್ದಿಷ್ಟ ವರ್ಗದೊಂದಿಗೆ ಸಂಬಂಧ ಹೊಂದಿದ್ದಾರೆ.

ಒಂದು ವಿಧಾನವನ್ನು ಸ್ಥಿರ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲು ಕೀವರ್ಡ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಸ್ಥಿರ.ಬಳಕೆದಾರರು ನಂತರ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ ವರ್ಗ. ವಿಧಾನ.ಬಳಕೆದಾರರು ವರ್ಗದ ನಿದರ್ಶನಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ಹೊಂದಿದ್ದರೂ ಸಹ ಈ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅಗತ್ಯವಿದೆ.

ಸ್ಥಿರ ( ಸ್ಥಿರ) ವಿಧಾನಗಳು, ಅಥವಾ ವರ್ಗ ವಿಧಾನಗಳು, ವಸ್ತುವಿನ ನಿದರ್ಶನವನ್ನು ರಚಿಸದೆಯೇ ಕರೆಯಬಹುದು. ಈ ವಿಧಾನವನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಮುಖ್ಯ.

ಸಾರ್ವಜನಿಕ ವರ್ಗ ಮಾದರಿ

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಇಂಟ್ a;

ಸಾರ್ವಜನಿಕ ಇಂಟ್ ಬಿ;

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ನಿರರ್ಥಕ DoubleA() ( a *= 2; )

ಸಾರ್ವಜನಿಕ ಶೂನ್ಯ SetB() (b = a;)

ಸಾರ್ವಜನಿಕ ವರ್ಗ ಅಪ್ಲಿಕೇಶನ್

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ()

ಮಾದರಿ sc1 = ಹೊಸ ಮಾದರಿ(), sc2 = ಹೊಸ ಮಾದರಿ();

Sample.a = 1;

sc1.SetB();

Sample.a = 2;

sc2.SetB();

Console.WriteLine("sc1.b = (0), sc2.b = (1)", sc1.b, sc2.b);

ಸ್ಥಿರ ವಿಧಾನಗಳ ಬಗ್ಗೆ ಕೊನೆಯ ಅಂಶವೆಂದರೆ ಸ್ಥಿರ ವಿಧಾನದಿಂದ ಯಾವ ವರ್ಗದ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುವ ನಿಯಮವಾಗಿದೆ. ನೀವು ಊಹಿಸುವಂತೆ, ಸ್ಥಿರ ವಿಧಾನವು ಯಾವುದನ್ನಾದರೂ ಕರೆಯಬಹುದು ಸ್ಥಿರ ಸದಸ್ಯತರಗತಿಯೊಳಗೆ, ಆದರೆ ನಿದರ್ಶನ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ನಂತರ ನಾವು ವರ್ಗದ ಹೆಸರು ಮತ್ತು ಸ್ಕೋಪ್ ರೆಸಲ್ಯೂಶನ್ ಆಪರೇಟರ್ ಮೂಲಕ ನೇರವಾಗಿ ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಆದರೆ ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯಬಲ್‌ಗಳು ಖಾಸಗಿಯಾಗಿದ್ದರೆ ಏನು? ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಸದಸ್ಯರು ಖಾಸಗಿಯಾಗಿರುವುದರಿಂದ ನಾವು ಯಾವುದನ್ನೂ ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ::s_value ಮುಖ್ಯ() ನಿಂದ. ವಿಶಿಷ್ಟವಾಗಿ, ಒಂದು ವರ್ಗದ ಖಾಸಗಿ ಸದಸ್ಯರನ್ನು ಸಾರ್ವಜನಿಕ ವಿಧಾನಗಳ ಮೂಲಕ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ. ನಾವು ರಚಿಸಬಹುದಾದರೂ ಸಾಮಾನ್ಯ ವಿಧಾನ s_value ಅನ್ನು ಪ್ರವೇಶಿಸಲು, ಆದರೆ ವಿಧಾನವನ್ನು ಬಳಸಲು ನಾವು ಈ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ! ಉತ್ತಮ ಆಯ್ಕೆ ಇದೆ - ನಾವು ವಿಧಾನವನ್ನು ಸ್ಥಿರವಾಗಿ ಮಾಡಬಹುದು.

ಸ್ಥಾಯೀ ಸದಸ್ಯ ಅಸ್ಥಿರಗಳಂತೆ, ಸ್ಥಿರ ವಿಧಾನಗಳು ಯಾವುದೇ ಒಂದು ವರ್ಗ ವಸ್ತುವಿಗೆ ಸಂಬಂಧಿಸಿಲ್ಲ. ಮೇಲಿನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ, ಆದರೆ ಇದರೊಂದಿಗೆ ಸ್ಥಿರ ವಿಧಾನ:

ವರ್ಗ ಯಾವುದಾದರೂ (ಖಾಸಗಿ: ಸ್ಥಿರ ಇಂಟ್ s_value; ಸಾರ್ವಜನಿಕ: ಸ್ಥಿರ ಇಂಟ್ getValue () ( ಹಿಂತಿರುಗಿ s_value; ) // ಸ್ಥಿರ ವಿಧಾನ ); int Anything ::s_value = 3; // ವರ್ಗ int main() ನ ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯಬಲ್‌ನ ವ್ಯಾಖ್ಯಾನ ( std::cout<< Anything::getValue() << "\n"; }

ಸ್ಥಿರ ವಿಧಾನಗಳು ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿಗೆ ಬದ್ಧವಾಗಿಲ್ಲದಿರುವುದರಿಂದ, ಅವುಗಳನ್ನು ವರ್ಗ ಹೆಸರು ಮತ್ತು ಸ್ಕೋಪ್ ರೆಸಲ್ಯೂಶನ್ ಆಪರೇಟರ್ ಮೂಲಕ ನೇರವಾಗಿ ಕರೆಯಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ವರ್ಗ ವಸ್ತುಗಳ ಮೂಲಕವೂ ಕರೆಯಬಹುದು (ಆದರೆ ಇದನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿಲ್ಲ).

ಸ್ಥಿರ ವಿಧಾನಗಳು ಈ * ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿಲ್ಲ

ಸ್ಥಿರ ವಿಧಾನಗಳು ಎರಡು ಆಸಕ್ತಿದಾಯಕ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿವೆ. ಮೊದಲನೆಯದಾಗಿ, ಸ್ಥಿರ ವಿಧಾನಗಳು ವಸ್ತುವಿಗೆ ಬದ್ಧವಾಗಿಲ್ಲದಿರುವುದರಿಂದ, ಅವುಗಳು ಹೊಂದಿಲ್ಲ! ಇದು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ, ಏಕೆಂದರೆ ಈ ಪಾಯಿಂಟರ್ ಯಾವಾಗಲೂ ವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಸ್ತುವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ವಸ್ತುವಿನ ಮೂಲಕ ಸ್ಥಿರ ವಿಧಾನಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸದಿರಬಹುದು, ಆದ್ದರಿಂದ ಈ ಪಾಯಿಂಟರ್ ಅಗತ್ಯವಿಲ್ಲ.

ಎರಡನೆಯದಾಗಿ, ಸ್ಥಿರ ವಿಧಾನಗಳು ಇತರ ಸ್ಥಿರ ಸದಸ್ಯರನ್ನು (ವೇರಿಯಬಲ್‌ಗಳು ಅಥವಾ ಕಾರ್ಯಗಳು) ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು, ಆದರೆ ಸ್ಥಿರವಲ್ಲದ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಏಕೆಂದರೆ ಸ್ಥಿರವಲ್ಲದ ಸದಸ್ಯರು ವರ್ಗ ವಸ್ತುವಿಗೆ ಸೇರಿದ್ದಾರೆ, ಆದರೆ ಸ್ಥಿರ ವಿಧಾನಗಳು ಅಲ್ಲ!

ಇನ್ನೊಂದು ಉದಾಹರಣೆ

ವರ್ಗ ದೇಹದ ಹೊರಗೆ ಸ್ಥಿರ ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಇದು ಸಾಮಾನ್ಯ ವಿಧಾನಗಳಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ವರ್ಗ IDGenerator (ಖಾಸಗಿ: ಸ್ಥಿರ ಇಂಟ್ s_nextID; // ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯಬಲ್ ಸಾರ್ವಜನಿಕ ಘೋಷಣೆ: ಸ್ಥಿರ ಇಂಟ್ getNextID (); // ಸ್ಥಿರ ವಿಧಾನದ ಘೋಷಣೆ ); // ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್‌ನ ವ್ಯಾಖ್ಯಾನವು ವರ್ಗ ದೇಹದ ಹೊರಗಿದೆ. ನಾವು ಇಲ್ಲಿ ಸ್ಥಿರ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತಿಲ್ಲ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ // 1 ಇಂಟ್ IDGenerator ನಲ್ಲಿ ID ಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಪ್ರಾರಂಭಿಸಿ::s_nextID = 1; // ಸ್ಥಿರ ವಿಧಾನದ ವ್ಯಾಖ್ಯಾನವು ವರ್ಗ ದೇಹದ ಹೊರಗಿದೆ. ನಾವು ಇಲ್ಲಿ int IDGenerator ::getNextID() ( ರಿಟರ್ನ್ s_nextID++; ) int main() ( ಗಾಗಿ (int count=0; count) ಸ್ಟ್ಯಾಟಿಕ್ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತಿಲ್ಲ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ< 4; ++count) std::cout << "The next ID is: " << IDGenerator::getNextID() << "\n"; return 0; }

ವರ್ಗ IDGenerator

ಖಾಸಗಿ:

ಸ್ಥಿರ ಇಂಟ್ s_nextID ; // ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯಬಲ್‌ನ ಘೋಷಣೆ

ಸಾರ್ವಜನಿಕ:

ಸ್ಥಿರ ಇಂಟ್ getNextID(); // ಸ್ಥಿರ ವಿಧಾನದ ಘೋಷಣೆ

// 1 ರಿಂದ ID ರಚಿಸಲು ಪ್ರಾರಂಭಿಸಿ

int IDGenerator ::s_nextID = 1;

int IDGenerator ::getNextID() (return s_nextID++;)

ಇಂಟ್ ಮುಖ್ಯ()

ಫಾರ್ (ಇಂಟ್ ಎಣಿಕೆ = 0 ; ಎಣಿಕೆ< 4 ; ++ count )

ಎಸ್ಟಿಡಿ:: ಕೌಟ್<< "The next ID is: " << IDGenerator :: getNextID () << "\n" ;

ಹಿಂತಿರುಗಿ 0;

ಫಲಿತಾಂಶ:

ಮುಂದಿನ ಐಡಿ: 1
ಮುಂದಿನ ಐಡಿ: 2
ಮುಂದಿನ ಐಡಿ: 3
ಮುಂದಿನ ಐಡಿ: 4

ಈ ವರ್ಗದ ಎಲ್ಲಾ ಅಸ್ಥಿರಗಳು ಮತ್ತು ಕಾರ್ಯಗಳು ಸ್ಥಿರವಾಗಿರುವುದರಿಂದ, ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು ಈ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ! ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಅದಕ್ಕೆ ನಿಯೋಜಿಸಬೇಕಾದ ಮುಂದಿನ ಗುರುತಿಸುವಿಕೆಯ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲು ಮತ್ತು ಅದನ್ನು ಹೆಚ್ಚಿಸಲು ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಎಲ್ಲಾ ಸ್ಥಿರ ಸದಸ್ಯರೊಂದಿಗೆ ತರಗತಿಗಳ ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆ

ಎಲ್ಲಾ ಸ್ಥಿರ ಸದಸ್ಯರೊಂದಿಗೆ ತರಗತಿಗಳನ್ನು ಬರೆಯುವಾಗ ಜಾಗರೂಕರಾಗಿರಿ. ಅಂತಹ "ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಿರ ವರ್ಗಗಳು" ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಅವುಗಳು ತಮ್ಮ ನ್ಯೂನತೆಗಳನ್ನು ಹೊಂದಿವೆ.

ಮೊದಲನೆಯದಾಗಿ, ಎಲ್ಲಾ ಸ್ಥಿರ ಸದಸ್ಯರನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ರಚಿಸಲಾಗಿರುವುದರಿಂದ, "ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಿರ ವರ್ಗ" ದ ಬಹು ಪ್ರತಿಗಳು ಇರುವಂತಿಲ್ಲ (ವರ್ಗವನ್ನು ಕ್ಲೋನ್ ಮಾಡದೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ಮರುಹೆಸರಿಸದೆ). ಉದಾಹರಣೆಗೆ, ನಮಗೆ ಎರಡು ಸ್ವತಂತ್ರ IDGenerator ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅಗತ್ಯವಿದ್ದರೆ, "ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಿರ" ವರ್ಗದ ಮೂಲಕ ಇದು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ಎರಡನೆಯದಾಗಿ, ಜಾಗತಿಕ ಅಸ್ಥಿರಗಳು ಅಪಾಯಕಾರಿ ಎಂದು ನಾವು ಪಾಠದಿಂದ ತಿಳಿದಿದ್ದೇವೆ ಏಕೆಂದರೆ ಯಾವುದೇ ಕೋಡ್‌ನ ಮೌಲ್ಯಗಳು ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು ಮತ್ತು ಸಂಬಂಧವಿಲ್ಲದ ಇತರ ಕೋಡ್‌ಗಳ ತುಣುಕುಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು (ಹೆಚ್ಚಿನ ವಿವರಗಳು). "ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಿರ" ತರಗತಿಗಳಿಗೆ ಇದು ನಿಜವಾಗಿದೆ. ಎಲ್ಲಾ ಸದಸ್ಯರು ವರ್ಗಕ್ಕೆ ಸೇರಿದವರಾಗಿರುವುದರಿಂದ (ಮತ್ತು ಅದರ ವಸ್ತುಗಳಲ್ಲ), ಮತ್ತು ತರಗತಿಗಳು ಜಾಗತಿಕ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿರುವುದರಿಂದ, "ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಿರ ವರ್ಗ" ದಲ್ಲಿ ನಾವು ಜಾಗತಿಕ ಕಾರ್ಯಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳನ್ನು ಅವರು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಮೈನಸಸ್ಗಳೊಂದಿಗೆ ಘೋಷಿಸುತ್ತೇವೆ.

C++ ಸ್ಥಿರ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ

ನೀವು ಮೂಲಕ ಸಾಮಾನ್ಯ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾದರೆ, ತಾರ್ಕಿಕವಾಗಿ ನೀವು ಸ್ಥಿರ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಮೂಲಕ ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಮತ್ತು ಕೆಲವು ಆಧುನಿಕ ಭಾಷೆಗಳು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಸ್ಥಿರ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸಿದರೆ, ಸಿ ++, ದುರದೃಷ್ಟವಶಾತ್, ಅವುಗಳಲ್ಲಿ ಒಂದಲ್ಲ.

ನಿಮ್ಮ ಸ್ಥಿರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನೇರವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದಾದರೆ, ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಅಗತ್ಯವಿಲ್ಲ: ಅದು ಖಾಸಗಿಯಾಗಿದ್ದರೂ ಸಹ ನೀವು ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ನಾವು ಇದನ್ನು ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ s_nextID ಯೊಂದಿಗೆ ಮಾಡುತ್ತೇವೆ. ಇನ್ನೊಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ವರ್ಗ ಯಾವುದೋ (ಸಾರ್ವಜನಿಕ: ಸ್ಥಿರ ಎಸ್ಟಿಡಿ:: ವೆಕ್ಟರ್ s_mychars; ); ಎಸ್ಟಿಡಿ:: ವೆಕ್ಟರ್ ಏನೋ::s_mychars = ( "o", "a", "u", "i", "e" ); // ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ

ಏನೋ ವರ್ಗ

ಸಾರ್ವಜನಿಕ:

ಸ್ಥಿರ ಎಸ್ಟಿಡಿ:: ವೆಕ್ಟರ್< char >s_mychars ;

ಎಸ್ಟಿಡಿ:: ವೆಕ್ಟರ್< char >ಏನೋ :: s_mychars = ( "o" , "a" , "u" , "i" , "e" ) ; // ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ

ನಿಮ್ಮ ಸ್ಥಾಯೀ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಗತ್ಯವಿದ್ದರೆ (ಲೂಪ್ ನಂತಹ), ನಂತರ ಅದನ್ನು ಮಾಡಲು ಕೆಲವು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳಿವೆ. ಮುಂದಿನ ವಿಧಾನವು ಉತ್ತಮವಾಗಿದೆ. ಇದು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣವಾಗಿರಬಹುದು (ಸದ್ಯಕ್ಕೆ) ಮತ್ತು ನಿಮಗೆ ಬಹುಶಃ ಇದು ಎಂದಿಗೂ ಅಗತ್ಯವಿಲ್ಲ, ನೀವು ಬಯಸಿದರೆ ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನ ಉಳಿದ ಭಾಗವನ್ನು ನೀವು ಸುರಕ್ಷಿತವಾಗಿ ಬಿಟ್ಟುಬಿಡಬಹುದು.

#ಸೇರಿಸು #ಸೇರಿಸು ವರ್ಗ ಯಾವುದೋ (ಖಾಸಗಿ: ಸ್ಥಿರ ಎಸ್ಟಿಡಿ:: ವೆಕ್ಟರ್ s_mychars; ಸಾರ್ವಜನಿಕ: ವರ್ಗ _ನೆಸ್ಟೆಡ್ // _ನೆಸ್ಟೆಡ್ ಎಂಬ ನೆಸ್ಟೆಡ್ ವರ್ಗವನ್ನು ವಿವರಿಸಿ (ಸಾರ್ವಜನಿಕ: _ನೆಸ್ಟೆಡ್() // _ನೆಸ್ಟೆಡ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ನಮ್ಮ ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (s_mychars.push_back("o"); s_mychars.push_back("a"); s_mychars.push_back ("u"); s_mychars.push_back("i");<< element << " "; } private: static _nested s_initializer; // используем статический объект класса _nested для гарантии того, что конструктор _nested выполнится }; std::vector// ಔಟ್‌ಪುಟ್‌ಗಾಗಿ ಸ್ಟ್ಯಾಟಿಕ್ ವಿಧಾನ s_mychars static void getSomething() ((ಆಟೋ ಕಾನ್ಸ್ಟ್ &ಎಲಿಮೆಂಟ್: s_mychars) std::cout

#ಸೇರಿಸು

ಏನೋ ವರ್ಗ

ಖಾಸಗಿ:

ಸ್ಥಿರ ಎಸ್ಟಿಡಿ:: ವೆಕ್ಟರ್< char >s_mychars ;

ಸಾರ್ವಜನಿಕ:

ಏನೋ ::s_mychars; // ನಮ್ಮ ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವಿವರಿಸಿ ಏನೋ ::_ನೆಸ್ಟೆಡ್ ಸಮ್ಥಿಂಗ್ ::s_initializer; // ನಮ್ಮ ಸ್ಟ್ಯಾಟಿಕ್ s_initializer ಅನ್ನು ವಿವರಿಸಿ, ಇದು s_mychars int main() ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು _nested ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯುತ್ತದೆ (ಏನೋ::getSomething(); 0 ಹಿಂತಿರುಗಿ; ) ವರ್ಗ_ನೆಸ್ಟೆಡ್

ಸಾರ್ವಜನಿಕ:

// _ನೆಸ್ಟೆಡ್ ಹೆಸರಿನ ನೆಸ್ಟೆಡ್ ವರ್ಗವನ್ನು ವಿವರಿಸಿ ನೆಸ್ಟೆಡ್ ()

// _ನೆಸ್ಟೆಡ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ನಮ್ಮ ಸ್ಥಿರ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ

s_mychars. ಪುಶ್_ಬ್ಯಾಕ್ ("ಒ");

s_mychars. ಪುಶ್_ಬ್ಯಾಕ್ ("ಎ");

s_mychars. ಪುಶ್_ಬ್ಯಾಕ್("ಯು");

s_mychars. ಪುಶ್_ಬ್ಯಾಕ್ ("ನಾನು");

s_mychars. ಪುಶ್_ಬ್ಯಾಕ್ ("ಇ");

ಸ್ಥಿರವು ಹೀಗಿರಬಹುದು:

ಸ್ಟ್ಯಾಟಿಕ್ ಅಸ್ಥಿರ ಮತ್ತು ಸ್ಥಿರ ವಿಧಾನಗಳನ್ನು ಮೊದಲು ನೋಡೋಣ.

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ಯಾಟಿಕ್ ವೇರಿಯೇಬಲ್ ಎಂದರೇನು?

ಜಾವಾದಲ್ಲಿನ ಸ್ಟ್ಯಾಟಿಕ್ ವೇರಿಯೇಬಲ್ ವರ್ಗಕ್ಕೆ ಸೇರಿರುವ ವೇರಿಯೇಬಲ್ ಆಗಿದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಪ್ರಾರಂಭದಲ್ಲಿ ಒಮ್ಮೆ ಮಾತ್ರ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.
ಇದು ವರ್ಗಕ್ಕೆ ಸೇರಿದ ವೇರಿಯೇಬಲ್ ಆಗಿದೆ ಮತ್ತು ವಸ್ತುವಿಗೆ ಅಲ್ಲ (ಉದಾಹರಣೆಗೆ)
ಸ್ಥಾಯೀ ಅಸ್ಥಿರಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಪ್ರಾರಂಭದಲ್ಲಿ ಒಮ್ಮೆ ಮಾತ್ರ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. ಯಾವುದೇ ನಿದರ್ಶನ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಈ ಅಸ್ಥಿರಗಳನ್ನು ಮೊದಲು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ
ವರ್ಗದ ಎಲ್ಲಾ ನಿದರ್ಶನಗಳಿಂದ ಹಂಚಿಕೊಳ್ಳಲು ಒಂದೇ ಪ್ರತಿ

<ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಅನ್ನು ವರ್ಗದ ಹೆಸರಿನಿಂದ ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಯಾವುದೇ ವಸ್ತುವಿನ ಅಗತ್ಯವಿಲ್ಲ

ವರ್ಗ-ಹೆಸರು>.

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್ ಎಂದರೇನು?

ಜಾವಾದಲ್ಲಿನ ಸ್ಥಾಯೀ ವಿಧಾನವು ವರ್ಗಕ್ಕೆ ಸೇರಿರುವ ಒಂದು ವಿಧಾನವಾಗಿದೆ ಮತ್ತು ವಸ್ತುವಿಗೆ ಅಲ್ಲ. ಸ್ಥಿರ ವಿಧಾನವು ಸ್ಥಿರ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು.
ಇದು ವರ್ಗಕ್ಕೆ ಸೇರಿದ ಒಂದು ವಿಧಾನವಾಗಿದೆ ಮತ್ತು ವಸ್ತುವಿಗೆ ಅಲ್ಲ (ಉದಾಹರಣೆಗೆ)
ಸ್ಥಿರ ವಿಧಾನವು ಸ್ಥಿರ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು. ಇದು ಸ್ಥಿರವಲ್ಲದ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ (ಉದಾಹರಣೆಗೆ ವೇರಿಯಬಲ್‌ಗಳು)
ಸ್ಥಿರ ವಿಧಾನವನ್ನು ವರ್ಗದ ಹೆಸರಿನಿಂದ ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಯಾವುದೇ ವಸ್ತುವಿನ ಅಗತ್ಯವಿಲ್ಲ
ಒಂದು ಸ್ಥಿರ ವಿಧಾನವು "ಇದು" ಅಥವಾ "ಸೂಪರ್" ಕೀವರ್ಡ್‌ಗಳನ್ನು ಹೇಗಾದರೂ ಉಲ್ಲೇಖಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

ಗಮನಿಸಿ:ಮುಖ್ಯ ವಿಧಾನವು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ, ಏಕೆಂದರೆ ಯಾವುದೇ ತತ್‌ಕ್ಷಣ ನಡೆಯುವ ಮೊದಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಅದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

ಕೆಲವು ವ್ಯಾಯಾಮಗಳನ್ನು ಮಾಡುವ ಮೂಲಕ ಸ್ಥಿರ ಕೀವರ್ಡ್‌ಗಳ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕಲಿಯೋಣ!

ಉದಾಹರಣೆ: ಸ್ಥಾಯೀ ಅಸ್ಥಿರಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಹೇಗೆ ಕರೆಯುವುದು

ಹಂತ 1)ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಸಂಪಾದಕಕ್ಕೆ ನಕಲಿಸಿ

ಪಬ್ಲಿಕ್ ಕ್ಲಾಸ್ ಡೆಮೊ(ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್)(ವಿದ್ಯಾರ್ಥಿ s1 = ಹೊಸ ವಿದ್ಯಾರ್ಥಿ(); s1.showData(); ವಿದ್ಯಾರ್ಥಿ s2 = ಹೊಸ ವಿದ್ಯಾರ್ಥಿ(); s2.showData(); //Student.b++; //s1 .showData(); ) ವರ್ಗ ವಿದ್ಯಾರ್ಥಿ ( int a; // zero static int b ಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ; // ರಚಿಸಲಾದ ಪ್ರತಿಯೊಂದು ವಸ್ತುವಿಗೆ ವರ್ಗವನ್ನು ಲೋಡ್ ಮಾಡಿದಾಗ ಮಾತ್ರ ಶೂನ್ಯಕ್ಕೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. b++; ))( //a++; //) )

ಹಂತ 2)ಕೋಡ್ ಅನ್ನು ಉಳಿಸಿ ಮತ್ತು ಕಂಪೈಲ್ ಮಾಡಿ. ಕೋಡ್ ಅನ್ನು ಹೀಗೆ ರನ್ ಮಾಡಿ ಜಾವಾ ಡೆಮೊ.

ಹಂತ 3)ಕೆಳಗೆ ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್ ಪ್ರದರ್ಶನ

ಕೆಳಗಿನ ರೇಖಾಚಿತ್ರವು ಉಲ್ಲೇಖ ವೇರಿಯೇಬಲ್‌ಗಳು ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ವಿಭಿನ್ನ ನಿದರ್ಶನಗಳಿಂದ ಸ್ಥಿರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ಹಂತ 4)ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗದ ಹೊರಗಿನಿಂದ ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿದೆ ClassName.Variable_Name. ಅನ್‌ಕಾಮೆಂಟ್ ಲೈನ್ #7 ಮತ್ತು 8. ಉಳಿಸಿ, ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು ರನ್ ಮಾಡಿ. ಔಟ್ಪುಟ್ ಅನ್ನು ಗಮನಿಸಿ.

a = 0 ಮೌಲ್ಯದ b = 1 ಮೌಲ್ಯದ a = 0 ಮೌಲ್ಯದ b = 2 ಮೌಲ್ಯದ a = 0 ಮೌಲ್ಯದ b = 3 ಹಂತ 5)ಅನ್‌ಕಾಮೆಂಟ್ ಲೈನ್ 25,26 ಮತ್ತು 27. ಉಳಿಸಿ, ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು ರನ್ ಮಾಡಿ.
ದೋಷ: ಸ್ಥಿರವಲ್ಲದ ವೇರಿಯಬಲ್ a ಅನ್ನು ಸ್ಥಿರ ಸಂದರ್ಭದಿಂದ ಉಲ್ಲೇಖಿಸಲಾಗುವುದಿಲ್ಲ a++;

ಹಂತ 6)ದೋಷ = ? ಏಕೆಂದರೆ ಇದು ನಿದರ್ಶನ ವೇರಿಯಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ " ಎ"ಜಾವಾ ಸ್ಟ್ಯಾಟಿಕ್ ಕ್ಲಾಸ್ ವಿಧಾನದಿಂದ" ಹೆಚ್ಚಳ".