Ruby/C3/Object-Oriented-Concept-in-Ruby/Punjabi

“Time”	“Narration”
00:01	ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ ਦੋਸਤੋ, Ruby ਵਿੱਚ object Oriented Concept ਦੇ ਇਸ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਡਾ ਸਾਰਿਆ ਦਾ ਸਵਾਗਤ ਹੈ ।
00:06	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਵਰਤੋਂ ਕਰਨਾ ਸਿੱਖਾਂਗੇ -
00:08	ਕਲਾਸੇਸ
00:09	ਆਬਜੈਕਟਸ ਬਣਾਉਣਾ
00:10	Ruby ਵਿੱਚ methods ਪਰਿਭਾਸ਼ਾ ਦੇ ਵੱਖਰੇ ਤਰੀਕੇ ।
00:13	ਇੱਥੇ ਅਸੀਂ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ
00:14	ਉਬੰਟੁ ਵਰਜ਼ਨ 12.04
00:16	Ruby 1.9.3
00:19	ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਜਾਣਨ ਦੇ ਲਈ ਤੁਹਾਨੂੰ ਲਿਨਕਸ ਕਮਾਂਡਸ, ਟਰਮੀਨਲ ਅਤੇ ਟੈਕਸਟ ਐਡੀਟਰ ਦਾ ਗਿਆਨ ਹੋਣਾ ਜ਼ਰੂਰੀ ਹੈ ।
00:24	ਜੇ ਨਹੀਂ, ਤਾਂ ਸੰਬੰਧਿਤ ਟਿਊਟੋਰਿਅਲ ਦੇ ਲਈ, ਸਾਡੀ ਵੈੱਬਸਾਈਟ ‘ਤੇ ਜਾਓ ।
00:28	ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਯਾਦ ਰੱਖੋ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ttt ਡਾਇਰੈਕਟਰੀ ਬਣਾਈ ਸੀ ।
00:33	ਹੁਣ ਉਸ ਡਾਇਰੈਕਟਰੀ ‘ਤੇ ਜਾਂਦੇ ਹਾਂ ।
00:35	ruby hyphen tutorial ਅਤੇ classes ਡਾਇਰੈਕਟਰੀ ‘ਤੇ
00:41	Ruby ਇੱਕ object oriented ਭਾਸ਼ਾ ਹੈ ।
00:44	Ruby ਵਿੱਚ ਵੈਲਿਊ ਤੋਂ string ਜਾਂ ਨੰਬਰ ਤੱਕ, ਸਭ ਕੁੱਝ ਇੱਕ ਆਬਜੈਕਟ ਹੈ;
00:49	ਇੱਕ class, ਸੰਬੰਧਿਤ data ਅਤੇ functions ਦਾ ਸੰਗ੍ਰਿਹ ਹੈ ।
00:53	ਇਹ ਸੰਗਠਿਤ ਜਾਣਕਾਰੀ ਨੂੰ ਰੱਖਣ ਦੇ ਕੰਮ ਆ ਸਕਦਾ ਹੈ ।
00:56	ਇੱਕ object, class ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ ।
01:00	ਇੱਕ class ਦੀ ਪਰਿਭਾਸ਼ਾ ਕੀਵਰਡ ਕਲਾਸ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ।
01:05	ਇਸਦੇ ਬਾਅਦ class ਦਾ ਨਾਮ ਆਉਂਦਾ ਹੈ ।
01:08	ਇਹ end ਦੇ ਨਾਲ ਸੀਮਾਬੱਧ ਹੁੰਦਾ ਹੈ ।
01:11	ਹੁਣ class ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖਦੇ ਹਾਂ ।
01:14	class Product
01:16	ruby ਕੋਡ
01:17	end
01:20	class ਦਾ ਨਾਮ ਕੈਪੀਟਲ ਲੈਟਰ ਤੋਂ ਸ਼ੁਰੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ।
01:24	ਨਾਮ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਤੋਂ ਜ਼ਿਆਦਾ ਸ਼ਬਦ ਹੋਣ, ਕੈਮਲ ਕੇਸ (camel case) ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ।
01:28	ਉਦਾਹਰਣ ਦੇ ਲਈ,
01:30	User Information
01:32	Product Information
01:34	ਬਾਅਦ ਵਾਲੀ ਫਾਇਲਸ ਦੇ ਨਾਮ ਦੇ ਸ਼ਬਦਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਵਿੱਚ ਅੰਡਰਸਕੋਰ ਦੀ ਵਰਤੋਂ ਹੋਵੇਗੀ ।
01:37	user underscore information
01:40	product underscore information
01:45	Ruby ਦੇ ਸ਼ੁਰੂਆਤੀ ਟਿਊਟੋਰਿਅਲਸ ਵਿੱਚ ਦਿਖਾਈ ਦੇ ਰਹੇ ਜਿਵੇਂ ਹੀ gedit ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਫਾਇਲ ਬਣਾਓ।
01:48	ਇਸ ਨੂੰ class_definition.rb ਨਾਮ ਦਿਓ ।
01:52	ਮੇਰੇ ਕੋਲ ਕਲਾਸੇਸ ਨੂੰ ਲਾਗੂ ਦੀ ਇੱਕ ਕਾਰਜਕਾਰੀ ਉਦਾਹਰਣ ਹੈ ।
01:57	ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਪੂਰਾ ਸਮਝਦੇ ਸਮੇਂ, ਮੱਧ ਵਿੱਚ ਰੋਕ ਕੇ ਕੋਡ ਟਾਈਪ ਕਰੋ ।
02:02	ਮੈਂ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ ਕਲਾਸ ਨਾਂ ਵਾਲੇ Order ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
02:05	ਹੁਣ, ਕੁੱਝ ਵੈਰੀਏਬਲਸ ਜੋੜਕੇ class ਨੂੰ ਵਰਤੋਂ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੇ ਹਾਂ ।
02:11	ਫਿਰ ਇੱਕ ਇੰਸਟੈਂਸ ਵੈਰੀਏਬਲ, myinstance ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
02:15	ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਵੈਲਿਊ ਨਿਯੁਕਤ ਕੀਤੀ ਹੈ ।
02:18	ਮੈਂ ਇੱਕ ਕਲਾਸ ਵੈਰੀਏਬਲ myclassvar ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
02:21	ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਵੈਲਿਊ ਨਿਯੁਕਤ ਕੀਤੀ ਹੈ ।
02:24	ਹੁਣ, ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਲਈ ਕੁੱਝ ਕੋਡ ਜੋੜਦੇ ਹਾਂ ।
02:30	ਟਾਈਪ ਕਰੋ, puts Order dot instance underscore variables.
02:36	ਇਸ ਲਾਈਨ ਤੋਂ ਪਹਿਲਾਂ, ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਦੇ ਲਈ puts ਕੁੱਝ ਕੈਰੇਕਟਰਸ ਸਲੈਸ਼ n ਜੋੜੋ ।
02:43	ਉਸ ਨੂੰ ਕਾਪੀ, ਪੇਸਟ ਕਰੋ ਅਤੇ ਜੋੜੀ ਹੋਈ ਲਾਈਨ ਦੇ ਹੇਠਾਂ ਇਸ ਨੂੰ ਜੋੜੋ ਅਤੇ ਇਸਨੂੰ ਸੇਵ ਕਰੋ ।
02:51	ਹੁਣ ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ।
02:53	ਟਰਮੀਨਲ ‘ਤੇ ਜਾਓ ਅਤੇ ਟਾਈਪ ਕਰੋ
02:56	ruby space class underscore definition dot rb
03:02	ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
03:05	ਤੁਸੀਂ, ਪਰਿਭਾਸ਼ਿਤ instance ਵੈਰੀਏਬਲ ਵੇਖੋਗੇ ।
03:09	ਹੁਣ ਟਾਈਪ ਕਰੋ puts Order dot class underscore variables.
03:15	ਇਸ ਸੀਮਾਵਾਂ ਨੂੰ, ਲਾਈਨ ਦੇ ਬਿਲਕੁੱਲ ਹੇਠਾਂ ਕਾਪੀ - ਪੇਸਟ ਕਰੋ ਅਤੇ ਸੇਵ ਕਰੋ ।
03:21	ਹੁਣ ਟਰਮੀਨਲ ‘ਤੇ ਜਾਓ ਅਤੇ ਪਹਿਲਾਂ ਦੀ ਤਰ੍ਹਾਂ ਹੀ ਫਾਇਲ ਨੂੰ ਚਲਾਓ ।
03:26	ਤੁਸੀਂ ਪਰਿਭਾਸ਼ਿਤ, ਕਲਾਸ ਵੈਰੀਏਬਲ ਵੇਖੋਗੇ, ਜੋ ਸਪੱਸ਼ਟ ਵੀ ਹੁੰਦੀ ਹੈ ।
03:32	ਹੁਣ ਤੁਸੀਂ ਆਪਣੀ ਕਲਾਸ ਲਿਖਣ ਲਈ ਸਮਰੱਥ ਹੋ ।
03:35	ਅੱਗੇ, ਵੇਖਦੇ ਹਾਂ ਕਿ ਆਬਜੈਕਟ ਕੀ ਹੈ ?
03:40	ਇੱਕ ਆਬਜੈਕਟ ਕਲਾਸ ਦਾ ਇੰਸਟੈਂਸ ਹੈ ।
03:43	ਜਿਸਦਾ ਮਤਲੱਬ, ਆਬਜੈਕਟ, ਕਲਾਸ ਤੋਂ ਬਣਦਾ ਹੈ ।
03:46	ਆਬਜੈਕਟ ਕਲਾਸ ਵਿੱਚ ਪ੍ਰਭਾਸ਼ਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਮੈਥਡਸ ਨੂੰ ਬਣਾ ਕੇ ਰੱਖੇਗਾ ।
03:52	ਤੁਸੀਂ ਆਬਜੈਕਟ ਕਿਵੇਂ ਐਲਾਨ ਕਰਦੇ ਹੋ
03:54	ਅਸੀਂ, ਇੱਕ ਨਵੇਂ ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਲਾਸ ਦਾ ਆਬਜੈਕਟ ਐਲਾਨ ਕਰਦੇ ਹਾਂ ।
03:58	ਇੱਥੇ ਅਸੀਂ Product ਕਲਾਸ ਦਾ ਆਬਜੈਕਟ ਐਲਾਨ ਕਰ ਰਹੇ ਹਾਂ ।
04:02	ਇੱਥੇ ਆਬਜੈਕਟ ਬਣ ਗਿਆ ਹੈ ।
04:05	product = Product.new
04:09	ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਆਬਜੈਕਟ ਦੀ ਸ਼ੁਰੂਆਤ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ।
04:12	ਇਹ ਆਬਜੈਕਟ Product ਦੀ ਕਿਸਮ ਹੈ ।
04:16	ਆਓ ਹੁਣ ਦੇਖੀਏ ਕਿ ਸ਼ੁਰੂਆਤੀ ਵਿਧੀ ਕੀ ਹੈ ?
04:20	initialize ਮੈਥਡ, ਆਬਜੈਕਟ ਬਣਾਉਂਦੇ ਸਮੇਂ ਕਾਲ ਹੋਇਆ ਹੈ ।
04:26	ਆਬਜੈਕਟ ‘ਤੇ ਨਿਊ (new) ਕਾਲ ਕਰਨ ਲਈ ਇਨਿਸ਼ਿਅਲਾਇਜ (initialize) ਮੈਥਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ।
04:31	ਇਨਿਸ਼ਿਅਲਾਇਜ ਮੈਥਡ ਦੇ ਕੋਲ ਪੈਰਾਮੀਟਰਸ ਦੀ ਸੂਚੀ ਹੋ ਸਕਦੀ ਹੈ ।
04:37	ਹੋਰ Ruby ਮੈਥਡਸ ਦੀ ਤਰ੍ਹਾਂ, ਇਹ def ਕੀਵਰਡ ਦੇ ਬਾਅਦ ਆਉਂਦਾ ਹੈ ।
04:43	ਇੱਕ ਉਦਾਹਰਣ ਵੇਖਦੇ ਹਾਂ ।
04:46	ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦੇ Ruby ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਤਰ੍ਹਾਂ ਹੀ gedit ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਫਾਇਲ ਬਣਾਓ।
04:50	ਅਤੇ ਇਸ ਨੂੰ object undescore initialize dot rb ਨਾਮ ਦਿਓ ।
04:55	ਮੇਰੇ ਕੋਲ ਆਬਜੈਕਟ ਸ਼ੁਰੂਆਤੀ (initialization) ਕੋਡ ਦੀ ਇੱਕ ਕਾਰਜਕਾਰੀ ਉਦਾਹਰਣ ਹੈ ।
05:00	ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਪੂਰਾ ਸਮਝਦੇ ਸਮੇਂ, ਮੱਧ ਵਿੱਚ ਰੋਕ ਕੇ ਕੋਡ ਟਾਈਪ ਕਰੋ ।
05:04	ਇੱਥੇ ਮੈਂ ਇੱਕ Order ਨਾਂ ਵਾਲੀ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
05:08	ਫਿਰ ਬਿਨ੍ਹਾਂ ਆਰਗਿਊਮੈਂਟ ਦੇ ਮੈਂ ਇੱਕ ਇਨਿਸ਼ਿਅਲਾਇਜ ਮੈਥਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
05:13	ਮੈਂ ਇੱਕ puts ਮੈਥਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ, ਇੱਕ ਮੈਸੇਜ ਦਿਖਾਉਣ ਦੇ ਲਈ, I have created an object.
05:20	ਅੱਗੇ, ਮੈਂ Order ਡਾਟ new ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
05:24	ਇਹ ਇਨਿਸ਼ਿਅਲਾਇਜ ਮੈਥਡ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ ।
05:27	ਟਰਮੀਨਲ ‘ਤੇ ਜਾਓ ਅਤੇ ਟਾਈਪ ਕਰੋ ।
05:31	ruby space object underscore initialize dot rb
05:36	ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
05:39	ਤੁਸੀਂ ਮੈਸੇਜ ਵੇਖੋਗੇ I have created an object.
05:43	ਹੁਣ ਵਾਪਸ gedit ‘ਤੇ ਜਾਓ ਅਤੇ ਮੈਥਡ ਵਿੱਚ ਇੱਕ ਆਰਗਿਊਮੈਂਟ ਜੋੜੋ ।
05:48	ਹੁਣ puts ਵਿੱਚ ਤਬਦੀਲੀ ਕਰਦੇ ਹਾਂ ।
05:51	ਇਹ ਪਾਸ ਕੀਤੇ ਹੋਏ ਆਰਗਿਊਮੈਂਟ ਦੀ ਵੈਲਿਊ ਨੂੰ ਦਰਸਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ।
05:55	ਅੱਗੇ ਟਾਈਪ ਕਰੋ
05:56	Order dot new (“I have created an object”).
06:04	ਇੱਥੇ ਅਸੀਂ ਨਿਊ ਮੈਥਡ ਨੂੰ ਇੱਕ ਆਰਗਿਊਮੈਂਟ ਦਿੱਤਾ ਹੈ ।
06:08	ਇਹ ਆਰਗਿਊਮੈਂਟ, ਇਨਿਸ਼ਿਅਲਾਇਜ ਮੈਥਡ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ।
06:13	ਟਰਮੀਨਲ ‘ਤੇ ਜਾਓ ਅਤੇ ਟਾਈਪ ਕਰੋ
06:16	ruby space object underscore initialize dot rb
06:20	ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
06:22	ਤੁਸੀਂ ਪ੍ਰਿੰਟ ਕੀਤਾ ਹੋਇਆ ਮੈਸੇਜ, “I have created an object” ਵੇਖੋਗੇ ।
06:29	ਹੁਣ, ਤੁਸੀਂ ਆਬਜੈਕਟ ਸ਼ੁਰੂਆਤੀ (initialization) ਦਾ ਮਤਲੱਬ ਸਮਝ ਚੁੱਕੇ ਹੋਵੋਗੇ ।
06:33	ਯਾਦ ਰੱਖੋ, Ruby ਵਿੱਚ ਫੰਕਸ਼ਨਸ ਹਨ, ਜੋ ਕਲਾਸ ਨੂੰ ਦਿਖਾਉਂਦੇ ਹਨ ।
06:39	ਕਲਾਸ ਵਿੱਚ ਹਰੇਕ ਮੈਥਡ def ਅਤੇ end ਬਲਾਕ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹੈ ।
06:45	ਮਲਟੀਵਰਡ ਮੈਥਡ ਨੇਮ, ਅੰਡਰਸਕੋਰ ਤੋਂ ਵੱਖ ਹੋਇਆ ਹੈ ।
06:48	ਕੁੱਝ ਕਰੈਕਟਰਸ (characters), ਜੋ ਮੈਥਡ ਨੇਮ ਦੇ ਨਾਲ ਨੱਥੀ ਹੋਏ ਹਨ ਹੇਠ ਲਿਖੇ ਹਨ:
06:54	? (question - mark)
06:56	= (equal to)
06:58	ਹਰੇਕ ਕਰੈਕਟਰ ਮੈਥਡ ਵਿੱਚ ਕੁੱਝ ਮਤਲੱਬ ਜੋੜਦਾ ਹੈ ।
07:02	ਹੁਣ ਕੁੱਝ ਉਦਾਹਰਣਾਂ ਵੇਖਦੇ ਹਾਂ ।
07:05	ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦੇ Ruby ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਤਰ੍ਹਾਂ ਹੀ gedit ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਫਾਇਲ ਬਣਾਓ।
07:09	ਅਤੇ ਇਸ ਨੂੰ class underscore methods dot rb ਨਾਮ ਦਿਓ ।
07:14	ਮੇਰੇ ਕੋਲ ਕਲਾਸ ਮੈਥਡਸ ਕੋਡ ਦੀ ਇੱਕ ਕਾਰਜਕਾਰੀ ਉਦਾਹਰਣ ਹੈ ।
07:17	ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਪੂਰਾ ਸਮਝਦੇ ਸਮੇਂ, ਮੱਧ ਵਿੱਚ ਰੋਕ ਕੇ ਕੋਡ ਟਾਈਪ ਕਰੋ ।
07:21	ਇੱਥੇ ਮੈਂ Animal ਨਾਂ ਵਾਲੀ ਇੱਕ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ।
07:23	ਫਿਰ ਮੇਰੇ ਕੋਲ ਦੋ ਮੈਥਡਸ ਹਨ breathe ਅਤੇ walk.
07:28	ਇਹ ਦੋਵੇਂ def ਅਤੇ end ਕੀਵਰਡਸ ਦੇ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਹੋਏ ਹਨ ।
07:32	ਫਿਰ ਮੈਂ ਆਬਜੈਕਟ Animal ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ ।
07:36	ਮੈਂ ਇਸ ਨੂੰ, ਵੈਰੀਏਬਲ animal ਨਿਯੁਕਤ ਕੀਤਾ, ਲੋਅਰਕੇਸ a ਦੇ ਨਾਲ ।
07:40	ਫਿਰ ਮੈਂ ਕ੍ਰਮ ਅਨੁਸਾਰ ਮੈਥਡਸ breathe ਅਤੇ walk ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ।
07:48	ਹੁਣ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਓ ।
07:51	ਟਰਮੀਨਲ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ ।
07:53	ruby space class underscore methods dot rb
07:58	ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
08:00	ਤੁਸੀਂ ਲਾਈਨਾਂ ਵੇਖੋਗੇ :
08:02	“ I breathe”
08:03	“ I walk”
08:04	ਪ੍ਰਿੰਟ ਹੋਈਆਂ ਹਨ ।
08:05	ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਦੋ ਮੈਥਡਸ breathe ਅਤੇ walk ਵਰਤੇ ਹਨ ।
08:10	puts ਸਟੇਟਮੈਂਟ, ਇਸ ਮੈਥਡਸ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹੈ, ਨਤੀਜਾ ਦਿੰਦਾ ਹੈ, ਜੋ ਤੁਸੀਂ ਵੇਖਦੇ ਹੋ ।
08:16	ਅੱਗੇ, ਵੇਖਦੇ ਹਾਂ ਕਿ ਇੱਕ ਅਨੁਗਾਮੀ question ਮਾਰਕ ਦੇ ਨਾਲ ਮੈਥਡਸ ਕਿਵੇਂ ਬਣਾਉਂਦੇ ਹਨ ।
08:21	ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦੇ Ruby ਟਿਊਟੋਰਿਅਲ ਦੀ ਤਰ੍ਹਾਂ ਹੀ gedit ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਫਾਇਲ ਬਣਾਓ।
08:25	ਅਤੇ ਇਸ ਨੂੰ class underscore methods underscore with underscore trailing underscore characters dot rb ਨਾਮ ਦਿਓ ।
08:35	ਮੇਰੇ ਕੋਲ question ਮਾਰਕ ਕੋਡ ਦੇ ਨਾਲ ਕਲਾਸ ਮੈਥਡਸ ਦੀ ਇੱਕ ਕਾਰਜਕਾਰੀ ਉਦਾਹਰਣ ਹੈ ।
08:40	ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਪੂਰਾ ਸਮਝਦੇ ਸਮੇਂ, ਮੱਧ ਵਿੱਚ ਰੋਕ ਕੇ ਕੋਡ ਟਾਈਪ ਕਰੋ ।
08:45	ਇੱਥੇ ਉਦਾਹਰਣ ਲਈ ਮੈਂ ਪਹਿਲਾਂ ਦੀ ਤਰ੍ਹਾਂ ਹੀ ਸਮਾਨ ਕਲਾਸ ਲਈ ਹੈ ।
08:48	ਇੱਥੇ breathe ਮੈਥਡ ਅਨੁਗਾਮੀ ਕਵੇਸ਼ਚਨ ਮਾਰਕ (question mark (?) ”) ਰੱਖਦਾ ਹੈ ।
08:52	ਅਜਿਹੇ ਮੈਥਡਸ ਆਮ ਤੌਰ 'ਤੇ: boolean ਵੈਲਿਊਜ ਰਿਟਰਨ ਕਰਨ ਵਿੱਚ ਵਰਤੋਂ ਹੁੰਦੇ ਹਨ ।
08:55	ਇਹ Ruby ਦੇ ਮੈਥਡ ਨੇਮਿੰਗ ਕਵੇਸ਼ਚਨ (naming convention) ‘ਤੇ ਆਧਾਰਿਤ ਹੈ ।
09:00	animal dot breathe question - mark, ਐਲਾਨ ਕਰਕੇ ਮੈਥਡ ਦੀ ਵਰਤੋਂ ਹੋਈ ਹੈ ।
09:06	ਟਰਮੀਨਲ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ
09:09	ruby space class underscore methods underscore with underscore trailing underscore characters dot rb ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
09:22	ਤੁਸੀਂ ਆਉਟਪੁਟ ਵਿੱਚ ਟਰੂ ਵੇਖੋਗੇ ।
09:26	ਅੱਗੇ, ਅਸੀਂ ਦੂਜੇ ਮੈਥਡ walk ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ।
09:30	ਇਸ ਦੇ ਕੋਲ ਇੱਕ ਸਾਇਨ ਲਗਾਓ equal to “= (value)”
09:36	animal dot walk, ਕਾਲ ਕਰਕੇ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ।
09:41	ਫਿਰ ਇਸ ਮੈਥਡ ਨੂੰ ਚਲਾਓ ।
09:44	ਟਰਮੀਨਲ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ
09:45	ruby class underscore methods underscore with underscore trailing underscore characters dot rb
09:52	ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
09:56	ਇਹ ਇੱਕ undefined ਮੈਥਡ ਐਰਰ ਦੇਵੇਗਾ ।
09:59	ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ equal to ਸਾਇਨ ਵੱਖਰਾ ਮਤਲੱਬ ਰੱਖਦਾ ਹੈ ।
10:03	ਇਹ ਇੱਕ ਮੈਥਡ ਨੂੰ ਵੈਲਿਊ ਨਿਯੁਕਤ ਕਰਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ।
10:08	ਹੁਣ, ਇਸ ਵਾਰ ਮੈਥਡ ਨੂੰ ਕੁੱਝ ਵੱਖਰੇ ਤਰੀਕੇ ਨਾਲ ਵਰਤਦੇ ਹਾਂ ।
10:13	ਟਾਈਪ ਕਰੋ puts animal dot walk equal to “ hops”
10:17	ਹੁਣ, ਇੱਕ ਹੋਰ ਕੋਸ਼ਿਸ਼ ਕਰੋ ।
10:20	ਟਰਮੀਨਲ ‘ਤੇ ਜਾਓ ਅਤੇ ਪਹਿਲਾਂ ਦੀ ਤਰ੍ਹਾਂ ਹੀ ਕਮਾਂਡ ਰਨ ਕਰੋ ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ ।
10:27	ਹੁਣ ਵੇਖਾਂਗੇ ਕਿ ਸ਼ਬਦ hops ਪ੍ਰਿੰਟ ਹੋਇਆ ਹੈ ।
10:30	ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਮੈਥਡ ਦੇ ਅੱਗੇ equal ਟੂ ਸਾਇਨ ਦਾ ਮਤਲੱਬ ਹੈ ਨਿਰਧਾਰਤ ਕੰਮ ।
10:36	ਹੁਣ ਤੁਸੀਂ ਆਪਣੇ ਮੈਥਡਸ ਨੂੰ ਲਿਖ ਸਕਦੇ ਹੋ ।
10:42	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਸਿੱਖਿਆ -
10:44	classes ਕਿਵੇਂ ਐਲਾਨ ਕਰੀਏ
10:46	ਕਲਾਸ ਦੇ ਆਬਜੈਕਟਸ ਕਿਵੇਂ ਬਣਾਈਏ
10:48	Ruby ਵਿੱਚ ਮੈਥਡਸ ਪਰਿਭਾਸ਼ਾ ਦੇ ਵੱਖਰੇ ਤਰੀਕੇ
10:52	ਇੱਕ ਨਿਰਧਾਰਤ ਕੰਮ ਦੀ ਤਰ੍ਹਾਂ:
10:54	ਇੱਕ class Product ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ।
10:56	myvar ਦੀ ਵੈਲਿਊਜ਼ ਅਤੇ myvar ਦੇ ਲਈ ਸੈੱਟ ਵੈਲਿਊਜ਼ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਲਈ ਮੈਥਡਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ।
11:01	ਵੈਲਿਊਜ਼ ਸੈੱਟ ਕਰਨ ਦੇ ਲਈ, “=” ਸਾਇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਥਡ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ।
11:05	ਕਲਾਸ ਦੇ ਆਬਜੈਕਟਸ ਨੂੰ ਜਲਦੀ ਦਰਸਾਉਣਾ ਅਤੇ ਉੱਪਰ ਦਿੱਤੇ ਦੋ ਮੈਥਡਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੈਲਿਊਜ਼ ਸੈੱਟ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨਾ ।
11:12	http://spoken-tutorial.org/What\_is\_a\_Spoken\_Tutoria ‘ਤੇ ਉਪਲੱਬਧ ਵੀਡੀਓ ਨੂੰ ਵੇਖੋ ।
11:14	ਇਹ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਾਰ ਕਰਦਾ ਹੈ ।
11:18	ਚੰਗੀ ਬੈਂਡਵਿਡਥ ਨਾ ਮਿਲਣ ‘ਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਡਾਊਂਨਲੋਡ ਕਰਕੇ ਵੀ ਵੇਖ ਸਕਦੇ ਹੋ ।
11:22	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ:
11:24	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ, ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਰਕਸ਼ਾਪਾਂ ਚਲਾਉਂਦੀ ਹੈ ।
11:27	ਆਨਲਾਇਨ ਟੈਸਟ ਪਾਸ ਕਰਨ ਵਾਲਿਆ ਨੂੰ ਪ੍ਰਮਾਣ ਪੱਤਰ ਵੀ ਦਿੰਦੇ ਹਨ ।
11:30	ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਦੇ ਲਈ, ਕ੍ਰਿਪਾ ਕਰਕੇ contact@spoken-tutorial.org ‘ਤੇ ਲਿਖੋ ।
11:36	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟਾਕ-ਟੂ-ਅ ਟੀਚਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਹਿੱਸਾ ਹੈ ।
11:39	ਇਹ ਭਾਰਤ ਸਰਕਾਰ ਦੇ ਐਮਐਚਆਰਡੀ ਦੇ “ਆਈਸੀਟੀ ਵਲੋਂ ਰਾਸ਼ਟਰੀ ਸਾਖਰਤਾ ਮਿਸ਼ਨ” ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਹੈ ।
11:46	ਇਸ ‘ਤੇ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਹੈ । http://spoken-tutorial.org/NMEICT-Intro
11:56	ਆਈ.ਆਈ.ਟੀ ਬੰਬੇ ਤੋਂ ਮੈਂ ਨਵਦੀਪ ਤੁਹਾਡੇ ਤੋਂ ਇਜਾਜ਼ਤ ਲੈਂਦਾ ਹਾਂ । ਸਾਡੇ ਨਾਲ ਜੁੜਨ ਲਈ ਧੰਨਵਾਦ ।	}

Contributors and Content Editors

Navdeep.dav