Lecture 04: Demonstration - I

Summary

The video script is a tutorial on Java programming, focusing on setting up the Java development environment, compiling, and executing Java programs. It covers essential topics like configuring the Java path, understanding class and file structure, and using commands for compiling and running Java code. The tutorial also includes creating and manipulating arrays, demonstrating loops for array elements, and calculating the sum and average of array values. The instructor guides through writing, compiling, and executing a simple 'Hello World' program, and progressively moves to more complex examples like 2D and 3D arrays, emphasizing the importance of syntax and output presentation.

Takeaways

• 😀 The script is a tutorial on setting up and running Java programs, emphasizing the importance of a proper development environment.
• 👨‍💻 It discusses the need for configuring the Java development kit (JDK) and setting environment variables like JAVA_HOME and PATH for smooth execution.
• 📁 The tutorial covers creating a project directory structure for organizing Java program files systematically.
• 🛠️ It provides a step-by-step guide on writing, compiling, and executing a basic 'Hello, World!' Java program to demonstrate the development process.
• 🔧 The script explains how to troubleshoot common issues encountered during Java program compilation and execution, such as class naming conflicts.
• 📊 It introduces the concept of arrays in Java and demonstrates how to declare, initialize, and iterate over array elements using loops.
• 🔑 The tutorial explains the use of nested loops to handle multi-dimensional arrays, specifically 3D arrays, and how to access and print their elements.
• 💡 It highlights the importance of proper syntax and indentation in Java code for readability and maintenance.
• 🖥️ The script suggests using an Integrated Development Environment (IDE) like Notepad++ for writing and compiling Java code efficiently.
• ⏯️ It concludes with a brief mention of upcoming topics, including applet programming, indicating a continuation of the Java learning series.

Q & A

What is the main topic of the video script?

The main topic of the video script is Java programming, focusing on how to run Java programs, setting up the development environment, and understanding various concepts related to Java programming.

What does the script suggest is necessary for strengthening Java programming skills?

The script suggests that understanding various resources and settings is necessary for strengthening Java programming skills.

What is the importance of setting up the development environment as mentioned in the script?

Setting up the development environment is important because it ensures that the computer is configured correctly to run Java programs, which is essential for a smooth programming experience.

What is the significance of the 'FirstJavaProgram.java' file in the script?

The 'FirstJavaProgram.java' file is significant as it represents the first Java program being demonstrated in the script, which is a common starting point for beginners learning Java.

Why is it crucial to match the class file name with the Java file name during compilation as per the script?

It is crucial to match the class file name with the Java file name during compilation because Java is case-sensitive, and the compiler uses the file name to locate the class definition, which must be an exact match.

What is the role of the 'javac' command in the script?

The 'javac' command is used to compile Java source files, converting the human-readable code into bytecode that can be run on the Java Virtual Machine.

How does the script explain the use of 'System.out.println()' in Java programs?

The script explains that 'System.out.println()' is used to print messages to the console, which is a fundamental way to display output in Java programs.

What is the purpose of the 'TestArray.java' program mentioned in the script?

The 'TestArray.java' program is used to demonstrate how to declare, initialize, and use arrays in Java, showcasing the manipulation of array elements and loops to iterate through them.

How does the script describe the process of running a Java program?

The script describes the process of running a Java program by first compiling the code using 'javac' and then executing it with the 'java' command, specifying the class name.

What is the significance of the '3DArray.java' example in the script?

The '3DArray.java' example is significant as it demonstrates the concept of three-dimensional arrays in Java, which is an advanced topic showing how to declare, initialize, and iterate through multi-dimensional arrays.

How does the script guide viewers to understand the output of a Java program?

The script guides viewers to understand the output of a Java program by explaining how to use print statements and how the console displays the results, emphasizing the importance of proper syntax and structure in the code.

Outlines

00:00

💻 Setting Up Java Programming Environment

The paragraph discusses the essentials of setting up and running Java programs, emphasizing the importance of various resources for strengthening Java programming skills. It introduces the concept of environment setup, suggesting that viewers ensure their devices are properly configured to run Java. It also touches on the need to set up a directory for organizing all Java programs and learning how to edit and make the program executable. The paragraph concludes with a mention of simple Java program demonstrations that will help viewers understand basic Java programming features.

05:01

🛠 Configuring Java Home and Path Variables

This section delves into the technical aspects of Java installation, focusing on setting up environment variables such as 'JAVA_HOME' and updating the system's 'Path' variable. It explains the necessity of pointing the 'JAVA_HOME' variable to the Java installation directory and including the 'bin' directory in the 'Path' variable for accessing Java executables. The paragraph also guides viewers on how to set these variables and ensures that the Java compiler and runtime are correctly configured to compile and run Java programs.

10:06

📝 Exploring Java Programming Basics

The paragraph introduces the process of writing and executing a basic Java program using a text editor. It describes how to save the program, navigate to the directory containing the program, and compile it using the Java compiler. The paragraph also explains how to run the compiled Java program and highlights the importance of matching the class name in the source file with the file name for successful compilation. It concludes with a demonstration of a simple 'Hello World' program, showcasing the basic syntax and structure of a Java program.

15:09

🔍 Debugging and Compiling Java Programs

This section discusses the process of debugging Java programs, highlighting common mistakes such as mismatched class and file names that can lead to compilation errors. It emphasizes the importance of careful naming and saving conventions to ensure successful compilation. The paragraph also demonstrates how to run a Java program and troubleshoot potential issues, such as ensuring the correct classpath and using the appropriate commands to compile and execute the program.

20:09

📈 Demonstrating Java Program with Arrays

The paragraph presents a Java program that utilizes arrays to demonstrate basic programming concepts like loops and array manipulation. It explains how to declare and initialize an array, iterate through its elements using a for loop, and perform operations like calculating the sum of array elements. The paragraph also shows how to print each element of the array and the total sum, providing a practical example of how arrays can be used in Java programs.

25:10

📚 Understanding 3D Arrays in Java

This section introduces the concept of 3D arrays in Java, explaining how to declare, initialize, and access elements in a three-dimensional array structure. It describes the process of creating a 3D array using nested loops and demonstrates how to iterate through the array to print its elements. The paragraph provides a comprehensive example of a 3D array program, illustrating the use of nested loops to access and display all elements in a structured manner.

Keywords

💡Java Programming

Java Programming refers to the process of writing, testing, and debugging Java code. In the context of the video, it is the main theme as the script discusses how to run Java programs and manipulate various resources in Java. The video emphasizes the importance of Java programming for enhancing one's skills, as indicated by phrases like 'your Java programming skills' and 'Java programming environment'.

💡Environment Setup

Environment Setup in the video script refers to the configuration of the system to run Java programs. This includes setting up the Java Development Kit (JDK) and ensuring that the system is correctly configured to compile and execute Java code. The script mentions 'setting up your machine' and 'project directory', which are crucial steps in preparing the environment for Java programming.

💡Compilation

Compilation in Java is the process of translating Java source code into bytecode that can be run by the Java Virtual Machine (JVM). The script mentions 'compiling the program' and 'compile the program files', which are key steps in the Java development workflow. The video likely covers how to use the 'javac' command to compile Java programs.

💡Execution

Execution in the context of the video refers to running the compiled Java bytecode using the JVM. The script discusses 'running the program' and 'execute the program', which are essential for seeing the output of Java programs. Understanding execution is vital for Java developers to test their code and ensure it works as expected.

💡Integrated Development Environment (IDE)

An IDE is a software application that provides comprehensive facilities for Java coding, such as smart code completion, debugging tools, and a built-in compiler. The script refers to 'Notepad++' as an example of an IDE, suggesting its use for writing and editing Java programs. IDEs are central to the Java development process, streamlining many aspects of coding and debugging.

💡Java Virtual Machine (JVM)

The JVM is the runtime environment in which Java programs run. The video script mentions 'Java Virtual Machine' in the context of running Java programs. The JVM is crucial as it allows Java's platform-independent execution, meaning Java programs can run on any device that has a JVM, regardless of the underlying operating system.

💡Java Code

Java Code refers to the set of instructions written in the Java programming language. The script contains phrases like 'Java program files' and 'Java code files', which are central to the video's discussion on Java programming. Java code is the foundation of any Java application, and the video likely covers how to write, compile, and execute Java code.

💡Variables

Variables in Java are used to store data values. The script mentions 'variables' in the context of setting up the Java environment, which suggests discussing how to declare and use variables in Java. Understanding variables is fundamental to Java programming as they are used to manipulate data within programs.

💡Loops

Loops are control structures that allow code to be executed repeatedly based on a given boolean condition. The script refers to 'loops' in the context of iterating over arrays and collections, which is a common use case in Java programming. Loops are essential for tasks that require repeated operations, such as processing elements in a list or array.

💡Arrays

Arrays are data structures that store multiple values in a single variable, often used to store a collection of similar data types. The script mentions 'arrays' in the context of Java programming, indicating a discussion on how to declare, initialize, and iterate over arrays. Arrays are a fundamental concept in Java for handling grouped data.

💡System.out.println()

System.out.println() is a Java method used to print data to the console. The script frequently mentions 'System.out.println()' as a way to output data from Java programs. This method is a basic tool for Java developers to display results or debug information on the console.

Highlights

Introduction to running Java programs and understanding various resources.

Emphasizing the importance of settings for effective Java programming.

Discussion on how to configure a laptop or any PC for running Java programs.

Guidance on executing programs from the project directory.

Advice on creating a folder to collect all developed programs.

Instructions on how to edit and make programs operational using various methods.

Final steps include creating simple programs to demonstrate basic Java programming features.

Explanation of setting up Java development kit (JDK) version 8.

Instructions for downloading and installing JDK on a computer.

Details on setting the Java system properties and environment variables.

Steps to configure the classpath variable for Java programs.

Demonstration of creating a simple Java program and explaining its components.

Process of compiling and running a Java program using the command prompt or terminal.

Common mistakes to avoid when naming Java files and classes.

Explanation of using the Notepad++ editor for writing and editing Java code.

Creating a 3D array in Java and understanding its structure and usage.

Nested for-loops to iterate through a 3D array and print its elements.

Practical demonstration of running a 3D array program and interpreting its output.

Conclusion and transition to the next lecture topic on applet programming.

Transcripts

ಆದ್ದರಿಂದ, ನಾವು ಜಾವಾ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು

ಹೇಗೆ ಚಲಾಯಿಸಬೇಕು ಮತ್ತು ನಂತರ ವಿವಿಧ

ಸಂಪನ್ಮೂಲಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೇವೆ.

ಇವು ನಿಮ್ಮ ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸಲು

ಅಗತ್ಯವಾಗಿವೆ.

ಆದ್ದರಿಂದ, ಇಂದು ನಾವು ಸೆಟ್ಟಿಂಗ್ ಬಗ್ಗೆ

ತ್ವರಿತ ಡೆಮೊವನ್ನು ಹೊಂದಿದ್ದೇವೆ ನಮ್ಮ

ಪರಿಸರವು ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ಗೆ ಸೂಕ್ತವಾಗಿದೆ.

ಇದರ ಜೊತೆಗೆ ನಾವು ಚರ್ಚಿಸೋಣ ಇನ್ನೂ ಕೆಲವು

ವಿಷಯಗಳು.

ಆದ್ದರಿಂದ, ನೀವು ಲ್ಯಾಪ್ಟಾಪ್ ಅಥವಾ ಯಾವುದೇ ಪಿಸಿ

ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ನಿಮ್ಮ ಯಂತ್ರವನ್ನು

ನೀವು ಸರಿಯಾಗಿ ಸಂರಚಿಸಬೇಕು.

ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ನಿಮ್ಮ

ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಬಹುದು.

ಆದ್ದರಿಂದ, ಒಂದು ಕೋಶವನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ನಿಮಗೆ

ಸಲಹೆ ನೀಡಬೇಕು.

ಆದ್ದರಿಂದ, ನೀವು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು

ನೀವು ಸಂಗ್ರಹಿಸಬಹುದು.

ಮತ್ತು, ನಂತರ ನಾವು ಸಹ ಕಲಿಯುತ್ತೇವೆ.

ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೇಗೆ ಸಂಪಾದಿಸಬಹುದು

ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ

ವಿವಿಧ ಹಂತಗಳ ಬಗ್ಗೆ.

ಪ್ರೋಗ್ರಾಂ.

ಅಂತಿಮವಾಗಿ, ನಾವು ಸರಳವಾದ ಸಣ್ಣ ಕಾರ್ಯಕ್ರಮಗಳ

ಕೆಲವು ಸರಳ ಪ್ರದರ್ಶನಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಮೂಲಭೂತ

ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ

ಹೇಗೆ ವ್ಯವಹರಿಸಬೇಕು ಎಂಬುದನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು.

ನಾವು ಸ್ವಲ್ಪ ಡೆಮೊ ಮಾಡೋಣ, ನನಗೆ ಅದು ಅರ್ಥವಾಗುತ್ತದೆ,

ಹೌದು.

ಆದ್ದರಿಂದ, ಸೈದ್ಧಾಂತಿಕ ಚರ್ಚೆಯಲ್ಲಿ, ನಾನು

ನೀವು ಜೆಡಿಕೆ ಆವೃತ್ತಿ 8 ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು

ಎಂದು ಉಲ್ಲೇಖಿಸಿದ್ದೀರಿ.

ನೀವು ಈಗಾಗಲೇ ಡೌನ್ಲೋಡ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು

ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಜೆಡಿಕೆ 8 ಅನ್ನು ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಅಳವಡಿಸಿ.

ಈಗ, ನೀವು ನಿಮ್ಮ ಜೆಡಿಕೆ ತಂತ್ರಾಂಶವನ್ನು ಸ್ಥಾಪಿಸಿದ್ದೀರಿ

ಎಂದು ಭಾವಿಸೋಣ.

ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ಗಳಲ್ಲಿ.

ಆದ್ದರಿಂದ, ನಾವು ಪ್ರೋಗ್ರಾಂ ಕಡತಗಳ ಕೋಶದಲ್ಲಿ ನಮ್ಮ

ಸ್ವಂತ ಯಂತ್ರದಲ್ಲಿ ನಿಖರವಾಗಿ ಸ್ಥಾಪಿಸಿರುವುದನ್ನು

ನೋಡುತ್ತೇವೆ.

ಜೆಡಿಕೆ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು

ಸ್ಥಾಪಿಸಿರುವುದನ್ನು ನೀವು ನೋಡಬಹುದು, ಅಂದರೆ

ಜೆಡಿಕೆ ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ಗಳ ಕೋಶದಲ್ಲಿದೆ;

ಇಲ್ಲಿ ಡೈರೆಕ್ಟರಿಯ ಹೆಸರು ಜೆಡಿಕೆ.

ಮತ್ತು, ಇದು ನಾವು ಸ್ಥಾಪಿಸಿರುವ ಆವೃತ್ತಿಯಾಗಿದೆ ಜೆಡಿಕೆ

ಆವೃತ್ತಿ 8 ಸರಿ.

ಅನುಸ್ಥಾಪನೆಯು ಯಶಸ್ವಿಯಾದ ನಂತರ ನೀವು ನಿಮ್ಮ

ಪ್ರೋಗ್ರಾಂ ಕೋಶದ ಮಾರ್ಗವನ್ನು ಹೊಂದಿಸಬೇಕು; ಅಂದರೆ,

ಎಲ್ಲಾ ಜಾವಾ ಉಪಕರಣಗಳು, ಜಾವಾ ಸಂಕೇತಗಳು, ಜಾವಾ

ಆಜ್ಞೆಗಳನ್ನು ಹೊಂದಿರುವ ಮುಖ್ಯ ಕೋಶ

ಸ್ಥಾಪಿಸಲಾಗಿದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಅದನ್ನು ಮಾಡಬೇಕು, ನಾನು ನಿಮಗೆ

ಹಂತ ಹಂತವಾಗಿ ನೀಡುತ್ತಿದ್ದೇನೆ.

ಮೊದಲು ನೀವು ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಹೋಗಬೇಕು ಮತ್ತು ನಂತರ

ನೀವು ಸುಧಾರಿತ ಸೆಟ್ಟಿಂಗ್ಗಳು ಮತ್ತು ಪರಿಸರಕ್ಕೆ

ಹೋಗಬೇಕು.

ವೇರಿಯೇಬಲ್ಗಳು ಮತ್ತು ನಂತರ ನೀವು ಜಾವಾ ಹೋಮ್

ಅನ್ನು ಹೊಂದಿಸಬೇಕು, ವೇರಿಯೇಬಲ್ ಹೆಸರು

ಜಾವಾಹೋಮ್ ನಂತರ ಜಾವಾ ಹೋಮ್ನ ವೇರಿಯೇಬಲ್

ಮೌಲ್ಯವನ್ನು ಸಿಃ// ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ಗಳು/ಜಾವಾ/ಜೆಡಿಕೆ

ನಲ್ಲಿ ಹೊಂದಿಸಬೇಕು.

ಇದು ಮೂಲತಃ ನೀವು ಸ್ಥಾಪಿಸಿರುವ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ನೀವು ಈ ವೇರಿಯೇಬಲ್ ಅನ್ನು

ಹೊಂದಿಸಬೇಕು.

ಈ ಮೌಲ್ಯದೊಂದಿಗೆ ಜಾವಾ ಹೋಮ್ ಎಂದು ಹೆಸರಿಸಿ.

ತದನಂತರ ನೀವು ಮಾರ್ಗವನ್ನು ನಿಗದಿಪಡಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ಈ ಹೆಸರನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಹೊಂದಿಸಬೇಕಾದ

ಮಾರ್ಗ ಜಾವಾ ಹೋಮ್ ನಂತರ ಜಾವಾ ಹೋಮ್ ಬಿನ್

ಅಡಿಯಲ್ಲಿ ಏಕೆಂದರೆ ಬಿನ್ ಮೂಲತಃ ಕಾರ್ಯಗತಗೊಳ್ಳಬಲ್ಲದು

ಎಲ್ಲಾ ಜಾವಾ ಕೋರ್ಸ್ಗಳಲ್ಲಿ, ಜಾವಾ ವ್ಯವಸ್ಥೆಗಳಿವೆ.

ಆದ್ದರಿಂದ, ಇದು ಭಾಗಗಳ ಸೆಟ್ಟಿಂಗ್ ಮತ್ತು

ನಂತರ ಅಂತಿಮವಾಗಿ, ನೀವು ತರಗತಿಯ ಮಾರ್ಗವನ್ನು

ನಿಗದಿಪಡಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ನೀವು ಕ್ಲಾಸ್ಪಾತ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು

ಸಿಃ// ಪ್ರೋಗ್ರಾಂನಿಂದ ಹೊಂದಿಸಬಹುದು.

ಕಡತಗಳು/ಜಾವಾ/ಜೆಡಿಕೆ . ಆದ್ದರಿಂದ, ಇದು

ಮೂಲತಃ ನಿಮ್ಮ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಅಥವಾ ಸಾಮಾನ್ಯ ಕಡತಗಳಾಗಿವೆ.

ಅದು ಎಲ್ಲಿರುತ್ತದೆ ಎಂದರೆ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನೀವು ಮಾರ್ಗಗಳನ್ನು ನಿಗದಿಪಡಿಸಬೇಕುಃ

ಒಂದು ಮಾರ್ಗ ತದನಂತರ ಸಿಸ್ಟಮ್ ವೇರಿಯೇಬಲ್ಗಳನ್ನು

ಈ ರೀತಿಯಲ್ಲಿ ಸಂರಚಿಸಲಾಗುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಯಾವುದೇ ಕೋಶದಿಂದ.

ಉದಾಹರಣೆಗೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಕೋಶವನ್ನು

ರಚಿಸಿದೆವು.

ಕೋಶದ ಹೆಸರು

ಎನ್ಪಿಟಿಇಎಲ್ ಜಾವಾ & ಜಿಟಿ; ಎಲ್ಲಾ ಅಂತಿಮ

& ಜಿಟಿ; ವಾರ 1 & ಜಿಟಿ; ಕೋಡ್ & ಜಿಟಿ; ಪ್ರದರ್ಶನ

1.

ಆದ್ದರಿಂದ, ಇಂದು ನಾವು ಒಂದು ಕೋಶವನ್ನು ರಚಿಸಿದೆವು

[ca/can] ಇದನ್ನು ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿ ಎಂದು ಕರೆಯಬಹುದು,

ಡೈರೆಕ್ಟರಿಯ ಹೆಸರು ಪ್ರದರ್ಶನವಾಗಿದೆ.

1.

ನಿಮ್ಮ ಸ್ವಂತ ತಿಳುವಳಿಕೆಯ ಪ್ರಕಾರ ನೀವು ನಿಮ್ಮ

ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಎಲ್ಲಿಯಾದರೂ ರಚಿಸಬಹುದು.

ನಿಮ್ಮ ಯಂತ್ರದಲ್ಲಿ, ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ,

ಯಾವುದೇ ಚಾಲನೆಯಲ್ಲಿ.

ಮತ್ತು, ಒಮ್ಮೆ ನೀವು ಅದನ್ನು ಮಾಡಿದರೆ ನಿಮಗೆ

ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಈಗ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರಚಿಸಲು, ನಿಮ್ಮ

ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು

ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಎಕ್ಸಿಕ್ಯುಟಿವ್

ಮಾಡಿ.

ಈಗ, ನೋಟ್ಪ್ಯಾಡ್ + + ಬಹಳ ಉತ್ತಮ ಸಂಪಾದಕವಾಗಿದೆ

ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳಿದ್ದೇನೆ, ಅದನ್ನು

ನೀವು ನಿಮ್ಮ ಸ್ವಂತದನ್ನು ಬರೆಯಲು ಪರಿಗಣಿಸಬಹುದು.

ಪ್ರೋಗ್ರಾಂ.

ಈಗ, ನಾನು ಈ ನೋಟ್ಪ್ಯಾಡ್ + + ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು

ತೆರೆಯುತ್ತಿದ್ದೇನೆ, ಇದರಿಂದ ನೀವು ನೋಡಬಹುದು.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಮೂಲತಃ ನೋಟ್ಪ್ಯಾಡ್

+ + ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ತೆರೆಯಲಾಗುತ್ತಿದೆ.

ಆದ್ದರಿಂದ, ಇದು ಮೂಲತಃ ಪಠ್ಯ ಸಂಪಾದಕವಾಗಿದ್ದು,

ನೀವು ಟೈಪ್ ಮಾಡಬಹುದಾದ ಯಾವುದೇ ವಿಷಯಗಳನ್ನು

ನೀವು ಟೈಪ್ ಮಾಡಬಹುದು.

ಕೀಬೋರ್ಡ್ನಿಂದ.

ಆದ್ದರಿಂದ, ಇದು ಯಾರಾದರೂ ಬಳಸಬಹುದಾದ ಸರಳ ಸಂಪಾದಕವಾಗಿದೆ,

ನಮ್ಮ ಉದ್ದೇಶ.

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯುವುದು; ನಾನು

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯುತ್ತಿದ್ದೇನೆ.

ಆದ್ದರಿಂದ, ನಾವು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ಈ ರೀತಿ ಪ್ರಾರಂಭಿಸೋಣ.

ನಾನು ಬರೆಯಲು ಹೊರಟಿರುವ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ನೋಡಿ, ನಾನು ಅದನ್ನು ಕೀಬೋರ್ಡ್ ಮೂಲಕ ಇಲ್ಲಿ

ಬರೆಯುವುದಿಲ್ಲ; ನಾನು ಈಗಾಗಲೇ ನಿಮಗಾಗಿ ಬರೆದಿದ್ದೇನೆ,

ನಾನು ಈ ಕಡತವನ್ನು ತೆರೆಯುತ್ತಿದ್ದೇನೆ.

ಆದ್ದರಿಂದ, ನಾನು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ತೆರೆಯುತ್ತಿದ್ದೇನೆ

ಮೊದಲ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ.

ಆದ್ದರಿಂದ, ಇದು ನಾವು ಡೆಮೊವನ್ನು ಹೊಂದಲಿರುವ

ಮೊದಲ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ಇದು ಅದರ ಹೆಸರಿನ ಪ್ರೋಗ್ರಾಂ

ಆಗಿದೆ, ಇದು ವರ್ಗದ ಹೆಸರು ಫಸ್ಟ್ ಜಾವಾ

ಪ್ರೋಗ್ರಾಮ್ ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಈಗ ನೀವು ನಿಮ್ಮ

ಕೀಬೋರ್ಡ್ನಿಂದ ಟೈಪ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು

ಭಾವಿಸಲಾಗಿದೆ.

ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಉಳಿಸುವುದು ಇದರ ಕಾರ್ಯವಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಸೇವ್ ಮೆನು ಇದೆ ಮತ್ತು ನೀವು ಸೇವ್

ಮೆನುವಿಗೆ ಹೋಗಬಹುದು ಹೀಗಾಗಿ, ಫರ್ಸ್ಟ್ಜಾವಾಪ್ರೋಗ್ರಾಮ್

ಅನ್ನು ಉಳಿಸಿ.

ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಉಳಿಸಲಾಗಿದೆ

ಮತ್ತು ನಂತರ ನೀವು ನಿಮ್ಮ ಡೈರೆಕ್ಟರಿಗೆ

ಹೋಗಬಹುದು ಅಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಈಗಾಗಲೇ ಇಲ್ಲಿ

ಉಳಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ನೋಡಬಹುದು.

ಉದಾಹರಣೆಗೆ, ಇಲ್ಲಿ ಫಸ್ಟ್ ಜಾವಾ FirstProgram.java

ಅನ್ನು ಇಲ್ಲಿ ಉಳಿಸಲಾಗಿದೆ.

ಒಮ್ಮೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಲಾಗಿದೆ.

ಮತ್ತು ಯಶಸ್ವಿಯಾಗಿ ಉಳಿಸಲಾಗಿದೆ, ಅದನ್ನು

ಸಂಕಲಿಸುವುದು ನಮ್ಮ ಮುಂದಿನ ಕಾರ್ಯವಾಗಿದೆ.

ಈ ಕಂಪೈಲರ್ಗಾಗಿ, ನಾವು ಕಮಾಂಡ್ ಪ್ರಾಂಪ್ಟಿಗೆ

ಹೋಗಬೇಕು.

ಆದ್ದರಿಂದ, ನೀವು ಆಜ್ಞೆಗೆ ಹೋಗಬೇಕು.

ಅದು ಇದ್ದರೆ ನಿಮ್ಮ ವಿಂಡೋಸ್ ಸಿಸ್ಟಮ್ನಿಂದ

ಪ್ರಾಂಪ್ಟ್ ಮಾಡಿ ಮತ್ತು ನಾವು ಯುನಿಕ್ಸ್ ಸಿಸ್ಟಮ್

ಅನ್ನು ಬಳಸಿದರೆ ನೀವು ಹೊಂದಿದ್ದೀರಿ ಟರ್ಮಿನಲ್

ಅನ್ನು ತೆರೆಯಲು ನೀವು ಅದನ್ನು ಕಮಾಂಡ್ ಅನ್ನು

ಟೈಪ್ ಮಾಡಲು ಬಳಸಬಹುದು.

ಈಗ, ಕಂಪೈಲ್ ಮಾಡಲು

ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂಗೆ ಅಗತ್ಯವಿರುವ ಆಜ್ಞೆಯು

ಜಾವಾಕ್ ಆಗಿದೆ ಮತ್ತು ನಂತರ ನೀವು ಪೂರ್ಣ

ಆಜ್ಞೆಯನ್ನು ನೀಡಬೇಕು.

ಕಡತದ ಹೆಸರು.

ನಮ್ಮ ಮೊದಲ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಉಳಿಸಲು ನಾವು

ಬಳಸಿದ ಕಡತವು FirstJavaProgram.java ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ನಾವು ನಿಮ್ಮ ವರ್ಗದ ಹೆಸರಿನಂತೆಯೇ

ಕಡತದ ಹೆಸರನ್ನು ನೀಡಬೇಕು.

ಅವರು ನೀಡಿದ್ದಾರೆ ಮತ್ತು ಇದು ಕೇಸ್ ಸೆನ್ಸಿಟಿವ್

ಆದ್ದರಿಂದ, ಅದರ ಬಗ್ಗೆ ಜಾಗರೂಕರಾಗಿರಿ.

ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು

ನಾವು ಕಂಪೈಲರ್ ಅನ್ನು ಆಹ್ವಾನಿಸಿದ ಜಾವಕ್ಗೆ

ಇದು ಉದಾಹರಣೆಯಾಗಿದೆ.

FirstJavaProgram.java.

ಈಗ, ಅದನ್ನು ಸರಿ ಎಂದು ಕಂಪೈಲ್ ಮಾಡೋಣ.

ಆದ್ದರಿಂದ, ಯಾವುದೇ ದೋಷವಿಲ್ಲ, ಯಾವುದೇ

ಸಂದೇಶವಿಲ್ಲ ಇದರ ಕಮಾಂಡ್ನಲ್ಲಿ ಈ ಪ್ರೋಗ್ರಾಂ ಯಶಸ್ವಿಯಾಗಿ

ಕಂಪೈಲ್ ಆಗಿದೆ ಎಂದರ್ಥ.

ಒಮ್ಮೆ ಯಶಸ್ಸು ಸಂಕಲನ, ನೀವು ಅದೇ ಕೋಶದಲ್ಲಿ

ಒಂದು ಕಡತವನ್ನು ರಚಿಸಲಾಗಿದೆ, ಕಡತದ ಹೆಸರನ್ನು ನೋಡಬಹುದು

. ಕ್ಲಾಸ್ ವಿಸ್ತರಣೆಯನ್ನು ಹೊರತುಪಡಿಸಿ ಇದು ಜಾವಾ

ಕಡತದ ಹೆಸರಿನಂತೆಯೇ ಇರುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ನೀವು ಮಾಡಬಹುದು ರಚಿಸಲಾದ

ಬೈಟ್ ಕೋಡ್ ಫೈಲ್ ಅನ್ನು FirstJavaProgram.class ಎಂದು ನೋಡಿ.

ಆದ್ದರಿಂದ, ಈ ಪ್ರೋಗ್ರಾಂ ಸಂಕಲನದಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿದೆ,

ಈಗ ನಾವು ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದೇವೆ.

ನಾವು ಅದನ್ನು ಬಳಸಲು ಹೇಳಿದ ಆಜ್ಞೆ ಜಾವಾ.

ಆದ್ದರಿಂದ, ಜಾವಾ ಮೊದಲ ಪ್ರೋಗ್ರಾಂ ಫಸ್ಟ್

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ನಂತರ . ಕ್ಲಾಸ್ ಅನ್ನು

ನೀವು ಬಳಸಬಹುದು ಅಥವಾ ನೀವು ಕ್ಲಾಸ್ ಅನ್ನು

ಬಳಸಿದರೂ ಸಹ ಯಾವುದೇ ಸಮಸ್ಯೆಯಿಲ್ಲ ಆದ್ದರಿಂದ

ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ವರ್ಗದ

ಕಡತದ ಹೆಸರು ಫರ್ಸ್ಟ್ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ಸರಳವಾಗಿ ಟೈಪ್ ಮಾಡಿ ಜಾವಾ ಮತ್ತು

ವರ್ಗ ಕಡತದ ಹೆಸರು, ಅಂದರೆ ಇಲ್ಲಿ ಫಸ್ಟ್

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ.

ಆದ್ದರಿಂದ, ಇದು ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ

ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ನೀವು ನೋಡುವಂತೆ

ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮೂಲತಃ ಕೇವಲ ಒಂದು

ಹೇಳಿಕೆಯನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ ಅವುಗಳೆಂದರೆ

System.out.println () ಮತ್ತು ಈ ಪ್ರಿಂಟ್ಲನ್ನಲ್ಲಿ

() ಮೂಲತಃ "ಅಭಿನಂದನೆಗಳು" ಎಂದು ಟೈಪ್ ಮಾಡಲಾಗುತ್ತದೆ.

ನಿಮ್ಮ ಮೊದಲ, ಕೇವಲ ತೆರೆಯಿರಿ ಅಥವಾ ಬ್ರೌಸ್

ಮಾಡಿ.

ಆದ್ದರಿಂದ, ಇದು "ನಿಮ್ಮ ಮೊದಲ ಜಾವಾ ಪ್ರೋಗ್ರಾಂಗೆ

ಅಭಿನಂದನೆಗಳು" ಎಂಬ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಯಶಸ್ವಿಯಾಗಿ ಓಡಿದೆ.

ಈಗ, ಔಟ್ಪುಟ್ ಕೂಡ ಅದೇ ವಿಷಯವನ್ನು ನೀಡುತ್ತದೆ

ಎಂದು ನಾವು ನೋಡಬಹುದು.

ಇದು ಮೂಲಭೂತವಾಗಿ

ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನೀವು ಸಂಪಾದಿಸಬೇಕಾದ

ಹಂತಗಳು, ಜಾವಾಕ್ ಬಳಸಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು ನಂತರ ಜಾವಾ

ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ರನ್ ಮಾಡಿ.

ಆದ್ದರಿಂದ, ನೀವು ಪರಿಗಣಿಸಬೇಕಾದ ಕೆಲವು ಹಂತಗಳು ಇವು

ಮತ್ತು ಈಗ ಹೇಳಿ, ಈ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ತಪ್ಪು ಇದೆ ಎಂದು ಭಾವಿಸೋಣ.

ಉದಾಹರಣೆಗೆ, ನೀವು ಫರ್ಸ್ಟ್ಜಾವಾಪ್ರೋಗ್ರಾಮ್1

ಎಂಬ ವರ್ಗ ಕಡತದ ಹೆಸರನ್ನು ನೀಡಿದ್ದೀರಿ, ಆದರೆ

ನೀವು ಉಳಿಸಿದ್ದೀರಿ.

ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು FirstJavaProgram.java ಎಂದು ಈ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು FirstJavaProgram.java ಎಂದು ಉಳಿಸಲಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಹೌದು ಇದು ನಾವು ರಚಿಸಿದ ಪ್ರೋಗ್ರಾಂ

ಆಗಿದೆ, ಆದರೆ ವರ್ಗ ಕಡತದ ಹೆಸರನ್ನು ನೋಡಿ

ನಾವು ರಚಿಸಿದ್ದು ಫರ್ಸ್ಟ್ಜಾವಾಪ್ರೋಗ್ರಾಮ್ 1, ಆದರೆ ಅದನ್ನು ಉಳಿಸಿದ

ಕಡತದ ಹೆಸರು FirstJavaProgram.java.

ಎರಡು ವಿಷಯಗಳು ಒಂದೇ ಅಲ್ಲ; ಇದರರ್ಥ ಈ ಸಂದರ್ಭದಲ್ಲಿ

ಸಂಕಲನವು ಯಶಸ್ವಿಯಾಗಬಾರದು.

ಈಗ, ನಾವು ಅದೇ ಜಾವಾಕ್ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ರನ್ ಮಾಡೋಣ.

FirstJavaProgram.java ಮತ್ತು ನಂತರ ಅದನ್ನು ಚಲಾಯಿಸಿ.

ಇಲ್ಲ, ನೀವು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ಹೊಂದಿಲ್ಲ, ವರ್ಗ ಕಡತವನ್ನು ಹೊಂದಿಲ್ಲ

ಅದು ಏನು.

ವರ್ಗ ಕಡತದ ಹೆಸರಿಗಿಂತ ಭಿನ್ನವಾಗಿದೆ.

ಹಾಗಾದರೆ, ಅದನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸಂಕಲಿಸುವುದು

ಹೇಗೆ?

ಸಂಕಲನ ಮಾಡಲಾಗುವುದು.

ಸಂಕಲನ ಯಶಸ್ಸು ಸಿಗಲಿದೆ.

ಈಗ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡುವುದನ್ನು

ನೋಡೋಣ.

ಆದ್ದರಿಂದ, ಓಡಲು ಜಾವಾ ಫಸ್ಟ್ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

ಈಗ ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ, ಸಂಕಲನ ಹೇಗೆ ಯಶಸ್ಸು

ಸಿಗಲಿದೆ.

ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು JavaProgram1.class ಎಂದು ಏಕೆ

ಸೇವ್ ಮಾಡಿದ್ದೇವೆ.

ಹೌದು.

ಹೌದು, ಈಗ ಇಲ್ಲಿ ನಾವು ಅದನ್ನು ಉಳಿಸಿರುವುದನ್ನು

ನೋಡಬಹುದು ಪ್ರೋಗ್ರಾಂ ಕಡತವು ಫರ್ಸ್ಟ್ಜಾವಾಪ್ರೋಗ್ರಾಮ್

ಎಂಬ ಹೆಸರಲ್ಲಿದೆ, ಆದರೆ ಅದರಲ್ಲಿ ಇರುವ

ವರ್ಗದ ಹೆಸರು ಈ ಪ್ರೋಗ್ರಾಂ ಫರ್ಸ್ಟ್ಜಾವಾ ಪ್ರೋಗ್ರಾಂ1

ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲ,

ಅಂದರೆ ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲ ಹೊಂದಾಣಿಕೆಯಾಗದಿದ್ದರೆ

ಸಂಕಲನವು ಯಶಸ್ವಿಯಾಗುವುದಿಲ್ಲ.

ಉದಾಹರಣೆಗೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ಯಶಸ್ವಿಯಾಗಿ ಕಂಪೈಲ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ನೀವು ಇದರ ಹೆಸರನ್ನು

ಗಮನಿಸಬೇಕು

ವರ್ಗ ಕಡತವು ಜಾವಾ ಕಡತದ ಹೆಸರಿನಂತೆಯೇ

ಇರಬೇಕು.

ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ

ಕಂಪೈಲ್ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಯಶಸ್ವಿಯಾಗಿ

ಕಂಪೈಲ್ ಮಾಡಿದರೆ ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು

ಸಾಧ್ಯವಾದರೆ ಕೆಲವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ.

ಈಗ, ನಾನು ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂನ ಮತ್ತೊಂದು

ಸರಳ ಪ್ರದರ್ಶನವನ್ನು ಹೊಂದಿದ್ದೇನೆ ಎಂದು

ನೋಡೋಣ.

ಆದ್ದರಿಂದ, ಹಲೋವರ್ಲ್ಡ್ ಹೌದು, ಈ ಪ್ರೋಗ್ರಾಂ

ಮತ್ತು ನಾನು ಬರೆಯುತ್ತಿದ್ದೇನೆ.

ಆದ್ದರಿಂದ, ನಾನು ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ರಮವನ್ನು

ಬರೆಯುತ್ತಿದ್ದೇನೆ.

ಅದರ ಹೆಸರನ್ನು ತಿಳಿಸೋಣ

ಪ್ರೋಗ್ರಾಂ helloworld.java ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ಹಲೋವರ್ಲ್ಡ್ ಇದು ಪ್ರೋಗ್ರಾಂ ಮತ್ತು

ಇದು ಕೇವಲ ಒಂದು ಹೇಳಿಕೆಯನ್ನು ಹೊಂದಿದೆ, ಇದು ಫಸ್ಟ್

ಜಾವಾ ಪ್ರೋಗ್ರಾಂಗೆ ಹೋಲುತ್ತದೆ.

ನಾನು ಅದನ್ನು ಸಂಯೋಜಿಸುತ್ತೇನೆ, ಜಾವಕ್ ಈ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು helloworld.java ಎಂದು ಉಳಿಸಲಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಜಾವಾ ಕಡತದ ಹೆಸರು

ಹಲೋವರ್ಲ್ಡ್, ಎಲ್ಲವೂ ಸಣ್ಣ ಅಕ್ಷರಗಳಲ್ಲಿ

helloworld.java.

ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಂ ಸಂಕಲನವು ಯಶಸ್ವಿಯಾದರೆ

ನಾವು ಅದನ್ನು ಚಲಾಯಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡಿ

ಜಾವಾವನ್ನು ಸರಿಯಾಗಿ ಬಳಸಿ, ಆದ್ದರಿಂದ, ಜಾವಾ

ಹಲೋವರ್ಲ್ಡ್.

ಸರಿ ಹೌದು; ಆದ್ದರಿಂದ ಇದು ಹಲೋ, ವರ್ಲ್ಡ್

ಅನ್ನು ನೀಡುತ್ತದೆ.

ಈಗ, ರಲ್ಲಿ ಅದೇ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಾನು ಮತ್ತೊಂದು ಸ್ಟೇಟ್ಮೆಂಟ್

ಸಿಸ್ಟಮ್ ಅನ್ನು ಸೇರಿಸುತ್ತಿದ್ದೇನೆ.

ಪ್ರಿಂಟ್ಲನ್ () System.out.println (). ಆದ್ದರಿಂದ, ಇಲ್ಲಿ

"ಹಲೋ, ವರ್ಲ್ಡ್" ಬದಲಿಗೆ ನಾನು "ಹಾಯ್" ಎಂದು ಟೈಪ್

ಮಾಡುತ್ತಿದ್ದೇನೆ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಎರಡು ಸಂದೇಶಗಳಿವೆಃ

ಮೊದಲ ಸಂದೇಶ "ಹಲೋ, ವರ್ಲ್ಡ್" ಮತ್ತು ಎರಡನೇ ಸಂದೇಶ

"ಹಾಯ್" ಅನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

ನಾನು ಮತ್ತೆ ಕಂಪೈಲ್ ಮಾಡುತ್ತಿದ್ದೇನೆ

ಮತ್ತು ನಂತರ ಮತ್ತೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿದ್ದೇನೆ.

ಆದ್ದರಿಂದ, ನೀವು ಹಲೋ, ವರ್ಲ್ಡ್ ಮತ್ತು ನಂತರ

ಹಾಯ್ ಅನ್ನು ನೋಡುತ್ತೀರಿ.

ಆದ್ದರಿಂದ,

ನೀವು ಪರದೆಯ ಮೇಲೆ ಕೆಲವು ಸಂದೇಶವನ್ನು

ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು

ಜಾವಾ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ System.out.println () ಅಗತ್ಯವಿದೆ.

ಮತ್ತು, ನೀವು ಏನನ್ನು ಬರೆಯುತ್ತೀರೋ ಅದು

ಎರಡು ವಾಕ್ಯಗಳಲ್ಲಿ ಬರೆಯಬಹುದು.

ಮೂಲತಃ ಮುದ್ರಣವು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ;

ಅಂದರೆ, ಅದು ಏನೇ ಬರೆಯಲ್ಪಟ್ಟಿದೆಯೋ ಹಾಗೆ.

ಅಲ್ಲಿ.

ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ ಹಾಯ್, ಮತ್ತೆ ಹಾಯ್.

.. .. ಡಬಲ್ ಉದ್ಧರಣದೊಳಗೆ ಮತ್ತು ಅದೇ ವಿಷಯ ಹಾಯ್.

.. .. ಸರಿ.

ಹಾಯ್.

.. .. ಸರಿ; ಈಗ ನೀವು ಅದನ್ನು ಮತ್ತೆ ಸೇವ್ ಮಾಡಿದರೆ

ಅದನ್ನು ರನ್ ಮಾಡಿ, ಅದು ಈ ರೀತಿ ಇರುತ್ತದೆ.

ಈಗ, ನೀವು ಒಂದು ಪ್ರಿಂಟ್ಲನ್ () ಹೇಳಿಕೆಯಲ್ಲಿ ಎರಡು

ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ, ನಾವು ಸಾಮಾನ್ಯವಾಗಿ

ಬಳಸುತ್ತೇವೆ.

ಪ್ಲಸ್ ಚಿಹ್ನೆ ಆದ್ದರಿಂದ, ಹಾಯ್ ಪ್ಲಸ್ ಇಲ್ಲ

ಹಾಯ್ + + ಡೆಬಾಸಿಸ್ ಸರಿ.

ಆದ್ದರಿಂದ, ಈಗ ಇಲ್ಲಿ ಮೂಲತಃ ಒಂದು ಸಾಲಿನಲ್ಲಿ,

ಅದು ಹಲೋ, ವರ್ಲ್ಡ್ ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ

ನಂತರ ಮುಂದಿನ ಸಾಲು ಹಾಯ್ ಮತ್ತು ನಂತರ

ಡೆಬಾಸಿಸ್ ಅನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ ಸರಿ ನೋಡಿ.

ಆದ್ದರಿಂದ, ಇದು ತುಂಬಾ ಸರಳವಾದ ಮತ್ತು ಸರಳವಾದ

ಹೇಳಿಕೆಯಾಗಿದೆ ಎಂದು ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ

ಎಂದು ಈಗ ನಿಮಗೆ ಭರವಸೆ ಇದೆ.

ವಾಸ್ತವವಾಗಿ, ಪ್ರೋಗ್ರಾಂ.

ಆದ್ದರಿಂದ, ನೀವು ಸರಳ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ಹೇಗೆ ಚಲಾಯಿಸಬಹುದು?

ಇದು ಉತ್ತಮ ಆರಂಭದ ಸ್ಥಳವಾಗಿದೆ

ನೀವು ನಿಜವಾಗಿಯೂ ಸರಿ.

ಈಗ, ನಾವು ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ಪರಿಗಣಿಸೋಣ, ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮೂಲತಃ ನಾವು

ಹೊಂದಿದ್ದೇವೆ ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಮತ್ತು ನಂತರ ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು

ಮತ್ತು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ಚರ್ಚಿಸಲಾಯಿತು.

ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಅಂಶ.

ಆದ್ದರಿಂದ, ಇದು ನಾವು ಇಲ್ಲಿ ಬರೆದಿರುವ ಒಂದು

ಪ್ರೋಗ್ರಾಂ ಆಗಿದ್ದು, ಪ್ರೋಗ್ರಾಂನ ಹೆಸರು

ಟೆಸ್ಟ್ ಅರೇ ಆಗಿದೆ, ಅಲ್ಲಿ ಕ್ಯಾಪಿಟಲ್

ಟಿ ಮತ್ತು ನಂತರ ಕ್ಯಾಪಿಟಲ್ ಅನ್ನು ನೀವು ಗಮನಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ಇದು ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು.

ನಿಮ್ಮ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು TestArray.java ಎಂದು ಉಳಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ಈ ಪ್ರಸ್ತುತ ಯೋಜನಾ ಕೋಶದಲ್ಲಿರುವ

ಕೋಶದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು TestArray.java ಎಂದು

ಉಳಿಸಲಾಗಿದೆ.

ಪರೀಕ್ಷೆಯು ಸರಿಯಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಇದು ನಾವು ಸಂಗ್ರಹಿಸಿರುವ ಪ್ರೋಗ್ರಾಂ

TestArray.java ಆಗಿದೆ.

ಈಗ, ನಾವು ಪ್ರೋಗ್ರಾಂ ಸ್ಟೇಟ್ಮೆಂಟ್ ಅನ್ನು

ಹೇಳಿಕೆಯ ಮೂಲಕ ನೋಡೋಣ, ನಾವು ಈ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.

ನಾವು ಈಗ ಏನು ಮಾಡಿದ್ದೇವೆ.

ಆದ್ದರಿಂದ, ಇದು ಟೆಸ್ಟ್ ಅರೇ ವರ್ಗದ ಹೆಸರು,

ಇದು

ಪ್ರೋಗ್ರಾಂನ ಹೆಸರು ಮತ್ತು ನಂತರ ಸಾರ್ವಜನಿಕ

ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಗಳು.

ಅಲ್ಲಿ ಎಂದಿನಂತೆ ನೀವು ಅನುಸರಿಸಬೇಕಾದ ಪ್ರಮಾಣಿತ

ವಾಕ್ಯರಚನೆಯು; ಈ ಹೇಳಿಕೆಯ ಅರ್ಥವನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೀರಿ.

ನಂತರ.

ಈಗ, ಮುಂದಿನದು ಮೂಲತಃ ನಾವು ಘೋಷಿಸಿದೆವು

ಶ್ರೇಣಿಯ ಪ್ರಕಾರದ ಪೂರ್ಣಾಂಕ.

ಆದ್ದರಿಂದ, ಚದರ ಬ್ರಾಕೆಟ್ನೊಳಗೆ ಇಂಟ್ ಎ ಮತ್ತು ನಂತರ

ಅದು ಮೂಲತಃ ಇನಿಶಿಯಲೈಸೇಶನ್ ಆಗಿದೆ.

ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ನಂತರ ಘೋಷಣೆಯನ್ನು

ಎಲ್ಲಾ ಮೂರು ವಿಷಯಗಳನ್ನು ಒಟ್ಟಿಗೆ ಮಾಡಲಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಇದು ಎರಡನೇ ಬ್ರಾಕೆಟ್ 10 20 30 ರೊಳಗೆ

ಸಮನಾಗಿರುವ ಅರೇ ಚಿಹ್ನೆಯ ಹೇಳಿಕೆಯಾಗಿದೆ. 40 50

ಆದ್ದರಿಂದ; ಅಂದರೆ, ರಚನೆಯು ಈಗ ಗಾತ್ರ

5 ಆಗಿದೆ.

ಮತ್ತು, ಈ ಶ್ರೇಣಿಯು 5 ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ಇವುಗಳನ್ನು 0 ಸ್ಥಳ 10 ಎ 1 ಸ್ಥಳ 20 ಎ 2 ಸ್ಥಳ

30 ಎ 3 ಸ್ಥಳ 40 ಮತ್ತು 4 ರಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

ಸ್ಥಳ 50.

ಆದ್ದರಿಂದ, ಈ ಶ್ರೇಣಿಯನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ

ಮತ್ತು ನಂತರ ಲೂಪ್ಗಾಗಿ ಮುಂದಿನದು, ಇದು ಲೂಪ್ಗಾಗಿ.

ಮೂಲತಃ ನಾವು ರಚನೆಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಅಂಶಗಳನ್ನು

ಮುದ್ರಿಸುತ್ತೇವೆ.

ಆದ್ದರಿಂದ, ಈ ಲೂಪ್

ಐ ಯಿಂದ ಪ್ರಾರಂಭವಾಗುವ ರೋಲ್ 0 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ

ಏಕೆಂದರೆ ರಚನೆಯ ಸೂಚ್ಯಂಕವು 0 ರಿಂದ ಇರುತ್ತದೆ ಮತ್ತು

ನಂತರ ಅದು ಲೂಪ್ ಆಗುತ್ತದೆ.

a.length () ಗಿಂತ ಕಡಿಮೆ i ಮೌಲ್ಯದವರೆಗೆ.

ಆದ್ದರಿಂದ, a.length () ಮೂಲತಃ ಗಾತ್ರ ಏನು ಶ್ರೇಣಿಯಲ್ಲಿ

a.

ಆದ್ದರಿಂದ, a.length () ಎಂಬುದು ನೀವು ಬಳಸಬಹುದಾದ ಒಂದು

ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವಾಗಿದೆ.

ರಚನೆಯ ಗಾತ್ರವನ್ನು ಹಿಂತಿರುಗಿಸಿ.

ಆದ್ದರಿಂದ, ಆ ಸಂದರ್ಭದಲ್ಲಿ, a.length () 5 ಆಗಿದೆ ಮತ್ತು

ನಂತರ ಮುಂದಿನದು ಮೂಲತಃ ಲೂಪ್ ವೇರಿಯೇಬಲ್ i

+ + ನ ಅನುಷ್ಠಾನ ಮತ್ತು ಈ ಲೂಪ್ System.out.println () ಒಳಗೆ.

ಆದ್ದರಿಂದ, ಇದು ಒಂದು ಸಮಯದಲ್ಲಿ ಶ್ರೇಣಿಯಲ್ಲಿ

ಒಂದು ಅಂಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಮುಂದಿನ

ಲೂಪ್ಗೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ಹೀಗೆ.

ಆದ್ದರಿಂದ, ಇದು ರಚನೆಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಟೈಪ್ ಮಾಡಿದರೆ ಪ್ರಿಂಟ್ಲನ್

() ಬದಲಿಗೆ ಅದನ್ನು ಮೂಲತಃ ಮುದ್ರಿಸಿ.

ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಮುದ್ರಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ln ಮತ್ತು ಮುದ್ರಣ ವ್ಯತ್ಯಾಸವೆಂದರೆ

ಅದು ಮೂಲತಃ ಒಂದು ಸಾಲಿನಲ್ಲಿ ಅಥವಾ ಬೇರೆ ಸಾಲಿನಲ್ಲಿ.

ಈಗ, ನಾನು ಸರಳವಾಗಿ ಚರ್ಚಿಸುವ ln ಅನ್ನು

ಹೊಂದೋಣ.

ನಂತರ ಪ್ರಿಂಟ್ಲನ್ () ಗೆ ಪರ್ಯಾಯವಾಗಿ ಮುದ್ರಿಸಿ.

ಈಗ, ಒಮ್ಮೆ ರಚನೆಯು ರಚನೆಯ ಅಂಶಗಳಾಗಿದ್ದಾಗ

ನಮ್ಮ ಮುಂದಿನ ಹಂತವು ಎಲ್ಲಾ ಅಂಶಗಳ ಸರಾಸರಿ

ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕ ಹಾಕುವುದು ಅವುಗಳನ್ನು

ಅಲ್ಲಿ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಮೊತ್ತ ಎಂದು ಕರೆಯಲಾಗುವ ಒಂದು

ವೇರಿಯೇಬಲ್ ಅನ್ನು ಘೋಷಿಸಿದೆವು ಮತ್ತು

ಅದು ಫ್ಲೋಟ್ ಎಂದು ಘೋಷಿಸಲಾಗಿದೆ ಮತ್ತು

ನಂತರ ಸರಾಸರಿ ಫ್ಲೋಟ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು

ಸಹ ಹೊಂದಿದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಎರಡು ಎಂದು ಘೋಷಿಸಿದೆವು.

ಅಸ್ಥಿರಗಳು; ಒಂದು ಮೊತ್ತ ಮತ್ತು ಇನ್ನೊಂದು

ಸರಾಸರಿ ಮತ್ತು ಮೊತ್ತವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ

a 0 ಘೋಷಣೆಯ ಸಮಯ.

ಈಗ, ಆದ್ದರಿಂದ ಮುಂದಿನ ಲೂಪ್ ಮೊತ್ತವನ್ನು

ಕಂಡುಹಿಡಿಯುವುದು

ಎಲ್ಲಾ ಅಂಶಗಳು ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇದು ಮೂಲತಃ

ಸರಾಸರಿ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕ ಹಾಕುತ್ತದೆ.

ರಚನೆಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಅಂಶಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯಿಂದ

ಅದು ರಚನೆಯ ಗಾತ್ರವಾಗಿದೆ.

ಮತ್ತು.

ಅಂತಿಮವಾಗಿ, ಒಂದು System.out.println () ಇದೆ ಮತ್ತು

ಇದು ಇದರೊಂದಿಗೆ ಸರಾಸರಿ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

ಸರಾಸರಿ ಸರಾಸರಿ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಎಂಬ

ಹೇಳಿಕೆ.

ಈಗ, ಜಾವಕ್ TestArray.java ಅನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ರನ್ ಮಾಡೋಣ, ಇದು ಪ್ರೋಗ್ರಾಂ ಕಡತದ

ಹೆಸರು ಸರಿ, ಅದನ್ನು ರನ್ ಮಾಡಿ.

ಆದ್ದರಿಂದ, ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ

ಕಂಪೈಲ್ ಮಾಡಲಾಗಿದೆ, ಈಗ ನಾವು ಈ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ಸರಿಯಾಗಿ ರನ್ ಮಾಡಲಿದ್ದೇವೆ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ನೀವು ಮೊದಲ ಕೆಲವು

ಸಾಲುಗಳನ್ನು ನೋಡುತ್ತೀರಿ 10 20 30 40 50 ಮೊದಲ ಫಾರ್ ಲೂಪ್ನ

ಫಲಿತಾಂಶವಾಗಿದೆ, ಇದು ಮೂಲತಃ ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ

ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಮತ್ತು, ಲೂಪ್ ಲೆಕ್ಕಾಚಾರಕ್ಕೆ ಮುಂದಿನದು ಶ್ರೇಣಿಯಲ್ಲಿ

ಸಂಗ್ರಹಿಸಲಾದ ಎಲ್ಲಾ ಅಂಶಗಳ ಮೊತ್ತ ಮತ್ತು

ಅಂತಿಮವಾಗಿ, ಸರಾಸರಿಯನ್ನು ಲೆಕ್ಕ ಹಾಕಿ ಇದನ್ನು

System.out.println () ಸರಾಸರಿಯೊಳಗೆ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ,

ಇದು ಈ ಸಂದರ್ಭದಲ್ಲಿ 30.0 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ.

ಈಗ, ನಾನು ಇಲ್ಲಿ ಮೊದಲ ಫಾರ್ ಲೂಪ್ನಲ್ಲಿ ಕೆಲವು

ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಬಯಸುತ್ತೇನೆ, ನಾನು

ಸಿಸ್ಟಮ್ ಅನ್ನು ಬರೆಯುತ್ತಿದ್ದೇನೆ.

ಪ್ರಿಂಟ್‌ ಇನ್‌ () ಸರಳ ಮುದ್ರಣದ ಬದಲಿಗೆ ಪ್ರಿಂಟ್‌

ಇನ್‌ () ಅನ್ನು ಔಟ್ ಮಾಡಿ ಮತ್ತು ನಂತರ

ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ.

ಸರಿಯಾದ ರನ್.

ಆದ್ದರಿಂದ, ಇದು ಸ್ವಲ್ಪ ಸುಲಭವಲ್ಲ, ನಾನು ಸ್ವಲ್ಪ

ಜಾಗವನ್ನು ಹಾಕಬಹುದು.

ಆದ್ದರಿಂದ, ನಾನು ಮುದ್ರಣಕ್ಕೆ ಹೋಗಿ ಮತ್ತೆ a.i + + ಅನ್ನು

ಮುದ್ರಿಸಬಹುದು ಮತ್ತು ನಂತರ ಡಬಲ್ ಕೋಟ್ ಜೊತೆಗೆ

ಡಬಲ್ ಕೋಟ್ ಅನ್ನು ಮುದ್ರಿಸಬಹುದು.

ಖಾಲಿ ಜಾಗ.

ಆದ್ದರಿಂದ, ನಾವು ಜಾಗವನ್ನು ನೀಡಿದರೆ, ಪ್ರದರ್ಶನವು

ಸಾಕಷ್ಟು ಆರಾಮವಾಗಿ ಗೋಚರಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಮುದ್ರಣ ಹೇಳಿಕೆಯನ್ನು ಈ ರೀತಿ

ಮಾಡುತ್ತೇವೆ.

ಆದ್ದರಿಂದ ಈಗ, ಇಲ್ಲಿ ನಾವು ಔಟ್ಪುಟ್ ಹೇಗೆ

ಎಂಬುದನ್ನು ನೋಡಬಹುದು.

ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಬಹುದಾಗಿದೆ.

ನಾನು ಬಲಭಾಗದ ಕೊನೆಯಲ್ಲಿ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾದ

ಔಟ್ಪುಟ್ ಮಾಡಬಹುದು.

System.out.println () ಲೂಪ್ಗೆ ಮೊದಲನೆಯದಾಗಿ, ಲೂಪ್ ಬ್ರಾಕೆಟ್ಗಳಿಗೆ

ಮೊದಲನೆಯದರ ಕೊನೆಯಲ್ಲಿ ನಿಮಗೆ ಇಲ್ಲಿ ತಿಳಿದಿದೆ,

ಇಲ್ಲಿ ನೀವು ಸರಿಯಾಗಿ System.out.print ln () ಎಂದು ಟೈಪ್

ಮಾಡಬಹುದು.

System.out.print ln () ಕೇವಲ ಬ್ರಾಕೆಟ್ಗಳ ಡಬಲ್ ಕೋಟ್ ಮಾತ್ರ

ಸರಿ.

ನಾನು ಈ ಅರೆ ಕೊಲೊನ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ

ಆದ್ದರಿಂದ, ನಾನು ನೋಡುತ್ತೇನೆ ಆದ್ದರಿಂದ ಮೊದಲ ಫಾರ್

ಲೂಪ್ನಲ್ಲಿ ಅದು ಎಲ್ಲವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಒಂದು

ಸಾಲಿನಲ್ಲಿ ಸಂಖ್ಯೆಗಳು, ನಂತರ ಫಾರ್ ಲೂಪ್ನ

ಕೊನೆಯಲ್ಲಿ ಅದು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗುತ್ತದೆ

ಮತ್ತು ನಂತರ ಮುಂದಿನ ಫಾರ್ ಲೂಪ್ನಲ್ಲಿ ಅದು

ಮೊತ್ತವನ್ನು ಲೆಕ್ಕ ಹಾಕುತ್ತದೆ ಮತ್ತು

ನಂತರ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ಮುದ್ರಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ ಈಗ, ನೀವು ನೀವು ಅದರ ಬಗ್ಗೆ ನೋಡುವಂತೆ,

ಪ್ರದರ್ಶನವನ್ನು ಹೆಚ್ಚು ಆರಾಮವಾಗಿ ಪ್ರಸ್ತುತಪಡಿಸಬಹುದೆಂದು

ನೋಡಿ, ಹೌದು ಈಗ ನೀವು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಬಹುದು.

ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಮುದ್ರಣವನ್ನು ನೀವು

ಹೇಗೆ ಸಂರಚಿಸಬಹುದು ಎಂಬುದು ಸರಳವಾದ ವಿಷಯವಾಗಿದೆ.

ಪ್ರದರ್ಶನದಲ್ಲಿ.

ಆದ್ದರಿಂದ, System.out.

println () ಅನ್ನು ಬಳಸಿ; ಈ System.out ಬಗ್ಗೆ ನಾವು ಕಲಿಯುತ್ತೇವೆ

ನಾವು ಈ ವಿಧಾನವನ್ನು ವಿವರವಾಗಿ ಚರ್ಚಿಸಿದಾಗ

ಬಹಳಷ್ಟು.

ಆದ್ದರಿಂದ, ನಾವು ಮತ್ತೊಂದು ಉದಾಹರಣೆಗೆ ಬರೋಣ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಇಲ್ಲಿ 3ಡಿಎರೆ

ಅನ್ನು ಪರಿಗಣಿಸುತ್ತೇವೆ.

ಈಗ, ಈ ಪ್ರೋಗ್ರಾಂನ ಹೆಸರನ್ನು ಫೈಲ್ನಂತೆ

3ಡಿ ಅರೆ ಎಂದು ನೀಡೋಣ ಮತ್ತು ನೀವು ಅದನ್ನು

ಉಳಿಸಬೇಕು.

ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು 3DArray.java ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನೀವು ಪ್ರೋಗ್ರಾಂ ಕಡತದ ಹೆಸರನ್ನು ನೋಡಿದರೆ

ಈ ಪ್ರೋಗ್ರಾಂ

3ಡಿ ಅರ್ರೇ ಇಲ್ಲಿ ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ

ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಗಳು ಎಂದಿನಂತೆ ಸರಿಯಾಗಿವೆ.

ಮತ್ತು, ಈಗ ನಾವು ಘೋಷಿಸಿದೆವು.

ಇಲ್ಲಿ.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ನಾವು ಒಂದು ರೀತಿಯ

ಅರೆ ಪೂರ್ಣಾಂಕವನ್ನು ಘೋಷಿಸಿದೆವು ಮತ್ತು

ನಾವು ಶ್ರೇಣಿಯನ್ನು ಮೈ3ಡಿಎರೇ ಎಂದು ಹೆಸರಿಸಿದೆ.

ಇದು 3ಡಿಎರೇ ಆಗಿರುವುದರಿಂದ, ಇದು 3 ಚದರವನ್ನು ಹೊಂದಿರಬೇಕು.

ಇಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಬ್ರಾಕೆಟ್ಗಳು ಮತ್ತು

ನಂತರ ಈ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಗುತ್ತದೆ

ಮತ್ತು ನಂತರ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ.

ಈ ಮೆಮೊರಿ ಹಂಚಿಕೆಗಾಗಿ, ನಾವು ಹೊಸ ಎಂಬ ಕೀವರ್ಡ್

ಅನ್ನು ಬಳಸುತ್ತೇವೆ; ಹೊಸದು ಮೂಲತಃ ನಿಗದಿಪಡಿಸಿದ

ಮೆಮೊರಿಯಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಇದು ರಚನೆಗೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ

ಮತ್ತು ಇಲ್ಲಿ ನೀವು 3 4 5 ಅನ್ನು 3 ಆಯಾಮಗಳಾಗಿ

ನೋಡುತ್ತೀರಿ.

ಆದ್ದರಿಂದ, ಮೊದಲ ಆಯಾಮವು ಪುಟಗಳ ಸಂಖ್ಯೆಗೆ,

ಎರಡನೆಯದು ಪುಟಗಳ ಸಂಖ್ಯೆಗೆ.

ಸಾಲುಗಳು ಮತ್ತು ಎರಡನೇ ಕೊನೆಯ ಆಯಾಮ 5 ಎಂದರೆ

ಕಾಲಮ್ಗಳ ಸಂಖ್ಯೆ.

ಆದ್ದರಿಂದ, ಅದು 2ಡಿ ಆಗಿದ್ದರೆ ಶ್ರೇಣಿಯು

ನಂತರ 4-5 ಆಗಿದೆ, ಅದು 3D ಶ್ರೇಣಿಯಾಗಿದ್ದರೆ

3-4-5 ಹಾಗೆ, 3 ಆಯಾಮಗಳು.

ಆದ್ದರಿಂದ, ಇದು ಮೂಲಭೂತವಾಗಿ ಇದು 3 2 ಆಯಾಮದ ವ್ಯೂಹ

3 2 ಆಯಾಮದ ವ್ಯೂಹಗಳ ಸಂಗ್ರಹವಾಗಿದೆ, ಅಲ್ಲಿ

ಪ್ರತಿ 2 ಆಯಾಮದ ವ್ಯೂಹವಿದೆ.

ಗಾತ್ರದ ಶ್ರೇಣಿ 4 ಸಾಲುಗಳು ಮತ್ತು 5 ಕಾಲಮ್ಗಳು.

ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಮೂಲತಃ ನಾವು ಅದನ್ನು

ಮುದ್ರಿಸಿದರೆ ಅದು ಮುದ್ರಿಸುತ್ತದೆ.

ವಾಸ್ತವವಾಗಿ 3 2 ಆಯಾಮದ ಸರಣಿಗಳಂತೆ.

ಹೇಗಾದರೂ ಈಗ, ನಾವು ಹೇಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು

ಎಂದು ನೋಡೋಣ, ಈ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದಾದ

ಒಟ್ಟು ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ನೀವು ಓದಬಹುದು 60 ಆಗಿದೆ.

ಆದ್ದರಿಂದ, ಕೀಬೋರ್ಡ್ನಿಂದ 60 ಶ್ರೇಣಿಯನ್ನು ಟೈಪ್

ಮಾಡುವುದು ಕೆಲವೊಮ್ಮೆ ಹೇಗಾದರೂ ತುಂಬಾ ಕಷ್ಟ.

ಆದ್ದರಿಂದ, ನಾವು ಈ ಶ್ರೇಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸಲು

ಲೂಪ್ಗಳಿಗೆ ಕೇವಲ ಒನ್ ಫಾರ್ 3 ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ.

ಈಗ, ಈ ಶ್ರೇಣಿಯನ್ನು ಆರಂಭಿಸಲು

ನಾನು ಒಂದನ್ನು ಬಳಸುತ್ತೇನೆ ಅಂದರೆ ನೆಸ್ಟೆಡ್ ಫಾರ್

ಲೂಪ್ ಎಂದು ನಾನು ಹೇಳಬೇಕು, ಇಲ್ಲಿ ನೆಸ್ಟೆಡ್ ಫಾರ್

ಲೂಪ್ ಅನ್ನು ನೋಡಿ.

ಈ ಲೂಪ್ 3 ಲೂಪ್ಗಳಿಗೆ ಸುತ್ತುತ್ತದೆ, ವಾಸ್ತವವಾಗಿ

ಕೆ = 0, ಕೆ & ಎಲ್ಟಿ; 5, ಕೆ + + ನೊಂದಿಗೆ ಅತ್ಯಂತ

ಒಳಗಿನ ಲೂಪ್.

ಒಳಗಿನ ಲೂಪ್ ಮೂಲತಃ 2 ಆಗಿದೆ, ಪ್ರತಿ ಕಾಲಮ್ನಲ್ಲಿ

ಒಂದು ಸಾಲಿನಲ್ಲಿರುವ ಅಂಶಗಳನ್ನು ಓದಿ.

ಆ ಸಾಲು.

ನಂತರ ಮುಂದಿನ ಅತ್ಯಂತ ಹೊರಗಿನ ಲೂಪ್ ij ಗೆ

0 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ, ಅದು 4 ಕ್ಕಿಂತ ಕಡಿಮೆ,

ಮೂಲತಃ ನಾವು ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು 1 2 ಆಯಾಮದ

ಶ್ರೇಣಿಯಲ್ಲಿ ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ.

ತದನಂತರ ಅಂತಿಮವಾಗಿ,

ಅತ್ಯಂತ ಹೊರಗಿನ ಲೂಪ್ ಅನ್ನು ಮೂಲತಃ ಪ್ರತಿ

3-ಆಯಾಮದ ರಚನೆಯನ್ನು, ಪ್ರತಿ 2-ಆಯಾಮದ ರಚನೆಯನ್ನು

ಓದಲಾಗುತ್ತದೆ.

3D ಸರಣಿಗಳಲ್ಲಿ.

ಮತ್ತು, ಇಲ್ಲಿ ಹೇಳಿಕೆಯು ಮೈ3ಡಿಎರೇ ಐ ಜೆ ಕೆ ಫಾರ್

ಐ ಜೆ ಕೆ ಯ ಯಾವುದೇ ಮೌಲ್ಯಗಳನ್ನು ಐ ಸ್ಟಾರ್ ಜೆ ಸ್ಟಾರ್

ಕೆ ಸ್ಟಾರ್ನ ಉತ್ಪನ್ನವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಈ ನಾವು ಶ್ರೇಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಮುಂದಿನ 3 ಲೂಪ್ಗಳನ್ನು

ಮತ್ತೆ ಮುದ್ರಿಸುತ್ತೇವೆ ಶ್ರೇಣಿಯನ್ನು.

ಈಗ, ಆದ್ದರಿಂದ ನಾವು ರಚನೆಯನ್ನು ಮುದ್ರಿಸಲು

ಪರಿಗಣಿಸಿರುವ ಹೇಳಿಕೆಯು ಮೂಲತಃ

ಮತ್ತೆ 3 ಲೂಪ್ಗಳು ರಚನೆಯನ್ನು ಲೋಡ್ ಮಾಡುವಂತೆಯೇ,

ರಚನೆಯನ್ನು ಅದೇ ರೀತಿಯಲ್ಲಿ ಪ್ರಾರಂಭಿಸುವುದು;

ಅದು ಮುದ್ರಿಸುವ ಮೌಲ್ಯವನ್ನು System.out.print () ಮೈ3ಡಿಎರೆ

ಎಂದು ಮಾತ್ರ ನಾವು ಬಳಸಿದ್ದೇವೆ.

ಆಮೇಲೆ ಅಂತಿಮವಾಗಿ, ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ

ಕರ್ಸರ್ಗೆ ನೀಡುವ ಕೊನೆಯ ಹೇಳಿಕೆ.

ಆದ್ದರಿಂದ, ಇದು ಮೂಲಭೂತವಾಗಿ 3ಡಿಎರೆ ಎಂದು ಘೋಷಿಸಿದ

ಪ್ರೋಗ್ರಾಂ ಆ ಶ್ರೇಣಿಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿತು

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಆ ಶ್ರೇಣಿಯಲ್ಲಿರುವ

ಅಂಶಗಳನ್ನು ಮುದ್ರಿಸಿ.

ಆದ್ದರಿಂದ, ಈಗ ನಾವು ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ರನ್ ಮಾಡೋಣ, ಆದರೆ ಮೊದಲು

ಓಡಲು ನಾವು ಅದನ್ನು ಕಂಪೈಲ್ ಮಾಡಬೇಕು,

ಜಾವಕ್ ಸರಿ ಹೌದು.

ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಂ ಸಂಕಲನವು ಯಶಸ್ವಿಯಾಗಿದೆ;

ಈಗ ಜಾವಾ ಓಕೆ ಬಳಸಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು

ರನ್ ಮಾಡಿ.

ಈಗ, ಇಲ್ಲಿ ನೀವು ಔಟ್ಪುಟ್ ಅನ್ನು ನೋಡುತ್ತೀರಿ.

ಆದ್ದರಿಂದ, 3ಡಿ ಅರೆ ಅನ್ನು ಮೂಲತಃ 3ಡಿ ಅರೆ

ಅನ್ನು ಪ್ರದರ್ಶಿಸಬಹುದು ಎಂದು ನಾನು ನಿಮಗೆ

ಹೇಳಿದೆ.a ನಾನು 3ಡಿಅರೆ ಯನ್ನು 2ಡಿ ಪ್ಲಾಟ್‌

ಪ್ರದರ್ಶಿಸಬೇಕಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಅದಕ್ಕಾಗಿಯೇ ನಾವು ಅದನ್ನು 3 2 ಡೈಮೆನ್ಷನಲ್‌

ಮೂಲಕ ಮಾಡಿದ್ದೇವೆ.

ಸರಣಿಗಳು.

ಆದ್ದರಿಂದ, ಮೊದಲ 2-ಆಯಾಮದ ಶ್ರೇಣಿಯು ಮೊದಲನೆಯದಾಗಿದೆ,

ನಾವು ಅದನ್ನು ಹೀಗೆ ಕರೆಯಬಹುದು

ಒಂದು ಹಂತ.

ಆದ್ದರಿಂದ, 1 ನೇ ಹಂತ ಮತ್ತು ನಂತರ 2 ನೇ ಹಂತಕ್ಕೆ

2 ನೇ 2-ಆಯಾಮದ ವ್ಯೂಹ ಮತ್ತು ನಂತರ 3 ನೇ 2-ಆಯಾಮದ

ವ್ಯೂಹ.

ಮೂರನೇ ಹಂತಕ್ಕೆ ಅರೇ ಮತ್ತು, ಪ್ರತಿ ಹಂತದಲ್ಲೂ

ಎಷ್ಟು ಸಾಲುಗಳಿವೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡಬಹುದು.

ಏನಿತ್ತು.

4ರ ವೆಚ್ಚ ಎಷ್ಟು?

5ರಷ್ಟಿದೆ. 4 ಸಾಲುಗಳು ಮತ್ತು 5 ಕಾಲಮ್ಗಳು

ಆದ್ದರಿಂದ 4 ಸಾಲುಗಳು ಮತ್ತು 5 ಕಾಲಮ್ಗಳು,

ಪ್ರತಿ ಎರಡು ಆಯಾಮದ ಶ್ರೇಣಿಯಲ್ಲಿ 4 ಸಾಲುಗಳು

ಮತ್ತು 5 ಕಾಲಮ್ಗಳಿವೆ.

ಆದ್ದರಿಂದ, ಇದು ನಾವು ಮಾಡಬಹುದಾದ ಮಾರ್ಗವಾಗಿದೆ

3D ಶ್ರೇಣಿಯನ್ನು ನಿರ್ವಹಿಸಿ.

ಈಗ, ನೀವು ಈಗಾಗಲೇ 3D ರಚನೆಯನ್ನು ಕಲಿತಿದ್ದೀರಿ,

ಕೇವಲ 2D ರಚನೆಯನ್ನು ಕಲಿಯುತ್ತಿದ್ದೀರಿ.

ಅದೇ ರೀತಿ.

ಆದ್ದರಿಂದ, ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಅದೇ ಪ್ರೋಗ್ರಾಂ

ಅನ್ನು ಮಾಡಿದರೆ ನೀವು 2 ಅನ್ನು ಮಾತ್ರ ಬಳಸಬೇಕಾಗುತ್ತದೆ.

ಪ್ರಾರಂಭಿಸಲು ಲೂಪ್ಗಳಿಗೆ ಮತ್ತು ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು

ಮುದ್ರಿಸಲು ಲೂಪ್ಗೆ 2.

ಆದ್ದರಿಂದ, ಇದು ನೀಡಲಾಗುತ್ತದೆ ನಿಮಗಾಗಿ ಒಂದು ಅಭ್ಯಾಸವಾಗಿ,

ನೀವು ಅದೇ ವಿಷಯವನ್ನು ಪುನರಾವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು,

2ಡಿ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಬಹುದು, ಪ್ರಾರಂಭಿಸಬಹುದು.

ಇದು ಕೆಲವು ಐ ಸ್ಟಾರ್ ಜೆ ಅನ್ನು ಬಳಸುತ್ತದೆ

ಮತ್ತು ನಂತರ ಅಂಶಗಳನ್ನು ಸರಿಯಾಗಿ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನೀವು ಇದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಬಹುದು,

ನೀವು ಅದನ್ನು ಕಲಿಯಬಹುದು.

ಆದ್ದರಿಂದ, ಇಂದು ನಮ್ಮ ಪ್ರದರ್ಶನವು ಈ ಮಟ್ಟದಲ್ಲಿದೆ

ಮತ್ತು ಮುಂದಿನ ಉಪನ್ಯಾಸದಲ್ಲಿ ನಾವು ಆಪ್ಲೆಟ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್

ಬಗ್ಗೆ ಚರ್ಚಿಸುತ್ತೇವೆ.

ಮತ್ತು, ಇದನ್ನು ಅನುಸರಿಸಿ ಚರ್ಚೆಯಲ್ಲಿ, ನಾವು

ಆಪ್ಲೆಟ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕುರಿತು ಪ್ರದರ್ಶನವನ್ನು

ನಡೆಸುತ್ತೇವೆ.

ವಂದನೆಗಳು.