Java Inheritance with its type and basic examples
Reference
https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
https://www.ebhor.com/java-inheritance/
The document discusses various Java I/O streams including input streams, output streams, byte streams, character streams, buffered streams, properties class, print stream, file locking, serialization and print writer class. It provides examples of reading and writing files using FileInputStream, FileOutputStream, FileReader, FileWriter and other stream classes. Methods of different stream classes are also explained along with their usage.
This document discusses inheritance in object-oriented programming. It defines inheritance as establishing a link between classes that allows sharing and accessing properties. There are three types of inheritance: single, multilevel, and hierarchical. Single inheritance involves one parent and one child class, multilevel inheritance adds intermediate classes, and hierarchical inheritance has one parent and multiple child classes. The document provides examples of inheritance code in Java and demonstrates a program using inheritance with interfaces. It notes some limitations of inheritance in Java.
The document provides information about strings in Java including:
1) Strings are objects in Java that are used to hold text data. The String class represents strings and provides various methods to work with strings.
2) There are two ways to create String objects: using string literals or the new keyword. String literals reuse existing objects in the string constant pool.
3) Important String class methods include charAt(), concat(), equalsIgnoreCase(), length(), replace(), substring(), toLowerCase(), toUpperCase(), and trim(). These methods allow manipulating and accessing string values.
The document discusses method overloading and overriding in Java. It defines method overloading as having multiple methods with the same name but different parameters, while overriding involves subclasses providing specific implementations of methods in the parent class. It provides examples of overloading methods by changing parameters and data types, and explains why overriding is not possible by only changing the return type due to ambiguity. The use of the super keyword to refer to parent class members is also explained.
A thread is an independent path of execution within a Java program. The Thread class in Java is used to create threads and control their behavior and execution. There are two main ways to create threads - by extending the Thread class or implementing the Runnable interface. The run() method contains the code for the thread's task and threads can be started using the start() method. Threads have different states like New, Runnable, Running, Waiting etc during their lifecycle.
This is the presentation file about inheritance in java. You can learn details about inheritance and method overriding in inheritance in java. I think it's can help your. Thank you.
This document discusses Java packages, including built-in and user-defined packages, advantages of packages, and how to access classes from other packages. Packages organize classes and interfaces, provide access protection, and avoid naming collisions. There are several ways to access classes from other packages, including importing the entire package, a specific class, or using the fully qualified class name. Subpackages further categorize packages. Class files can be loaded temporarily via the classpath or permanently by modifying environment variables or creating JAR files.
This document discusses interfaces in Java. It defines an interface as a blueprint of a class that defines static constants and abstract methods. Interfaces are used to achieve abstraction and multiple inheritance in Java. They represent an "is-a" relationship. There are three main reasons to use interfaces - for abstraction, to support multiple inheritance functionality, and to achieve loose coupling. The document provides examples of interfaces, such as a Printable interface and implementations in different classes. It also demonstrates multiple inheritance using interfaces and interface inheritance.
The document discusses various Java I/O streams including input streams, output streams, byte streams, character streams, buffered streams, properties class, print stream, file locking, serialization and print writer class. It provides examples of reading and writing files using FileInputStream, FileOutputStream, FileReader, FileWriter and other stream classes. Methods of different stream classes are also explained along with their usage.
This document discusses inheritance in object-oriented programming. It defines inheritance as establishing a link between classes that allows sharing and accessing properties. There are three types of inheritance: single, multilevel, and hierarchical. Single inheritance involves one parent and one child class, multilevel inheritance adds intermediate classes, and hierarchical inheritance has one parent and multiple child classes. The document provides examples of inheritance code in Java and demonstrates a program using inheritance with interfaces. It notes some limitations of inheritance in Java.
The document provides information about strings in Java including:
1) Strings are objects in Java that are used to hold text data. The String class represents strings and provides various methods to work with strings.
2) There are two ways to create String objects: using string literals or the new keyword. String literals reuse existing objects in the string constant pool.
3) Important String class methods include charAt(), concat(), equalsIgnoreCase(), length(), replace(), substring(), toLowerCase(), toUpperCase(), and trim(). These methods allow manipulating and accessing string values.
The document discusses method overloading and overriding in Java. It defines method overloading as having multiple methods with the same name but different parameters, while overriding involves subclasses providing specific implementations of methods in the parent class. It provides examples of overloading methods by changing parameters and data types, and explains why overriding is not possible by only changing the return type due to ambiguity. The use of the super keyword to refer to parent class members is also explained.
A thread is an independent path of execution within a Java program. The Thread class in Java is used to create threads and control their behavior and execution. There are two main ways to create threads - by extending the Thread class or implementing the Runnable interface. The run() method contains the code for the thread's task and threads can be started using the start() method. Threads have different states like New, Runnable, Running, Waiting etc during their lifecycle.
This is the presentation file about inheritance in java. You can learn details about inheritance and method overriding in inheritance in java. I think it's can help your. Thank you.
This document discusses Java packages, including built-in and user-defined packages, advantages of packages, and how to access classes from other packages. Packages organize classes and interfaces, provide access protection, and avoid naming collisions. There are several ways to access classes from other packages, including importing the entire package, a specific class, or using the fully qualified class name. Subpackages further categorize packages. Class files can be loaded temporarily via the classpath or permanently by modifying environment variables or creating JAR files.
This document discusses interfaces in Java. It defines an interface as a blueprint of a class that defines static constants and abstract methods. Interfaces are used to achieve abstraction and multiple inheritance in Java. They represent an "is-a" relationship. There are three main reasons to use interfaces - for abstraction, to support multiple inheritance functionality, and to achieve loose coupling. The document provides examples of interfaces, such as a Printable interface and implementations in different classes. It also demonstrates multiple inheritance using interfaces and interface inheritance.
This document provides an overview of serialization in Java. Serialization allows an object to be written to a stream and reconstructed from that stream later. When an object is serialized, its field values are written to preserve the object's state. The transient keyword can exclude fields from serialization. Serialization uses ObjectOutputStream to write objects and ObjectInputStream to read them back. Unique identifiers prevent version conflicts during deserialization. Classes can implement Externalizable for full control over serialization.
The document provides an overview of Java applets, including:
1. An applet is a Java program that can be embedded in an HTML page and runs in web browsers.
2. Advantages of applets include being cross-platform, supported by most browsers, and cached for faster loading.
3. Disadvantages include requiring the Java plugin and JVM, and being slower to load than HTML.
Method overloading in Java allows methods within a class to have the same name but different parameters. It increases readability and allows methods to perform similar tasks with different input parameters. Method overloading is determined by Java by first matching the method name and then the number and type of parameters. It can be done based on the number of parameters, data type of parameters, or sequence of data types in parameters. The main advantage is that it performs tasks efficiently with variations in argument types or numbers under the same method name. A disadvantage is that it can be difficult for beginners and requires more design effort in the parameter architecture.
Inheritance allows a derived class to inherit properties from a base or parent class. A derived class inherits attributes and behaviors of the base class and can add its own attributes and behaviors. There are different types of inheritance including single, multilevel, multiple, hierarchical, and hybrid inheritance. Inheritance promotes code reuse and reduces development time.
The document discusses exception handling in Java. It defines exceptions as runtime errors that occur during program execution. It describes different types of exceptions like checked exceptions and unchecked exceptions. It explains how to use try, catch, throw, throws and finally keywords to handle exceptions. The try block contains code that might throw exceptions. The catch block catches and handles specific exceptions. The finally block contains cleanup code that always executes regardless of exceptions. The document provides examples of exception handling code in Java.
- Java inner classes are classes declared within other classes or interfaces. They allow grouping of logically related classes and interfaces and can access all members of the outer class, including private ones.
- There are three main advantages of inner classes: they can access private members of the outer class, they make code more readable by grouping related classes, and they require less code.
- The two types of inner classes are non-static (inner) classes and static nested classes. Non-static classes can access outer class members like private variables while static classes cannot access non-static members only static ones.
- Examples demonstrate member inner classes, anonymous inner classes, local inner classes, and static nested classes in Java and how they can
Introduction to method overloading & method overriding in java hdmHarshal Misalkar
This document introduces method overloading and method overriding in Java. Method overloading allows a class to have multiple methods with the same name but different parameters. It increases readability. Method overriding allows a subclass to provide a specific implementation of a method declared in the parent class. It is used for runtime polymorphism where the method being called is determined by the object type. The document provides examples of method overloading by changing number/type of arguments and of method overriding where the subclass overrides the parent's display method.
Chapter 02: Classes Objects and Methods Java by Tushar B KuteTushar B Kute
The lecture was condcuted by Tushar B Kute at YCMOU, Nashik through VLC orgnanized by MSBTE. The contents can be found in book "Core Java Programming - A Practical Approach' by Laxmi Publications.
This document discusses inheritance in Java. It defines inheritance as allowing new classes to reuse properties of existing classes. There are different types of inheritance including single, multilevel, and hierarchical. Key concepts covered include defining subclasses using the extends keyword, using the super keyword to call parent constructors and access parent members, overriding methods, abstract classes and methods, and using the final keyword to prevent overriding or inheritance.
This document discusses classes, objects, and methods in Java. It defines a class as a user-defined data type that contains fields and methods. Objects are instances of classes that allocate memory at runtime. Methods define behaviors for objects and are declared within classes. The document covers defining classes, creating objects, accessing members, constructors, method overloading and overriding, static members, passing objects as parameters, recursion, and visibility control.
Here, class PQR contains an object of class ABC as its data member. So class PQR contains class ABC through object ob1. This is an example of containership relationship between classes in OOP.
Streams are used to transfer data between a program and source/destination. They transfer data independently of the source/destination. Streams are classified as input or output streams depending on the direction of data transfer, and as byte or character streams depending on how the data is carried. Common stream classes in Java include FileInputStream, FileOutputStream, FileReader, and FileWriter for reading from and writing to files. Exceptions like FileNotFoundException may occur if a file cannot be opened.
This document provides an overview of basic object-oriented programming (OOP) concepts including objects, classes, inheritance, polymorphism, encapsulation, and data abstraction. It defines objects as entities with both data (characteristics) and behavior (operations). Classes are blueprints that are used to create objects. Inheritance allows objects to inherit properties from parent classes. Polymorphism allows code to take different forms. Encapsulation wraps data and functions into classes, hiding information. Data abstraction focuses on important descriptions without details.
Constructor is a special member method which will be called automatically when you create an object of any class.
The main purpose of using constructor is to initialize an object.
http://www.tutorial4us.com/java/java-constructor
This document provides an overview of client-server networking concepts in Java. It discusses elements like network basics, ports and sockets. It explains how to implement both TCP and UDP clients and servers in Java using socket classes. Sample code is provided for an echo client-server application using TCP and a quote client-server application using UDP. Exception handling for sockets is also demonstrated.
In this you learn about
--Constructors in Java
--Types of Constructors
1. Default Constructor
2. Parameterized Constructor
Difference between Constructor and Method
Java is a general-purpose computer-programming language that is concurrent, class-based, object-oriented,[15] and specifically designed to have as few implementation dependencies as possible
Type casting involves assigning a value of one data type to a variable of another type. There are two types of casting: widening (implicit) and narrowing (explicit). Widening casting converts data to a broader type without needing explicit casting, like converting an int to a long. Narrowing casting converts to a narrower data type and requires explicit casting, such as converting a double to a long.
This document discusses key object-oriented programming concepts in Java including inheritance, interfaces, polymorphism, and method overriding. It provides examples of how subclasses inherit fields and methods from parent classes, how to call parent class constructors, and how child class methods can override parent class methods of the same signature. The document also covers how interfaces define public abstract methods and variables, and how classes implement interfaces by overriding interface methods.
This document discusses key object-oriented programming concepts in Java including inheritance, interfaces, polymorphism, and method overriding. It provides examples of how subclasses inherit fields and methods from parent classes, how to call parent class constructors, and how child class methods can override parent class methods of the same signature. The document also covers how interfaces define public abstract methods and variables, and how classes implement interfaces by overriding interface methods.
This document provides an overview of serialization in Java. Serialization allows an object to be written to a stream and reconstructed from that stream later. When an object is serialized, its field values are written to preserve the object's state. The transient keyword can exclude fields from serialization. Serialization uses ObjectOutputStream to write objects and ObjectInputStream to read them back. Unique identifiers prevent version conflicts during deserialization. Classes can implement Externalizable for full control over serialization.
The document provides an overview of Java applets, including:
1. An applet is a Java program that can be embedded in an HTML page and runs in web browsers.
2. Advantages of applets include being cross-platform, supported by most browsers, and cached for faster loading.
3. Disadvantages include requiring the Java plugin and JVM, and being slower to load than HTML.
Method overloading in Java allows methods within a class to have the same name but different parameters. It increases readability and allows methods to perform similar tasks with different input parameters. Method overloading is determined by Java by first matching the method name and then the number and type of parameters. It can be done based on the number of parameters, data type of parameters, or sequence of data types in parameters. The main advantage is that it performs tasks efficiently with variations in argument types or numbers under the same method name. A disadvantage is that it can be difficult for beginners and requires more design effort in the parameter architecture.
Inheritance allows a derived class to inherit properties from a base or parent class. A derived class inherits attributes and behaviors of the base class and can add its own attributes and behaviors. There are different types of inheritance including single, multilevel, multiple, hierarchical, and hybrid inheritance. Inheritance promotes code reuse and reduces development time.
The document discusses exception handling in Java. It defines exceptions as runtime errors that occur during program execution. It describes different types of exceptions like checked exceptions and unchecked exceptions. It explains how to use try, catch, throw, throws and finally keywords to handle exceptions. The try block contains code that might throw exceptions. The catch block catches and handles specific exceptions. The finally block contains cleanup code that always executes regardless of exceptions. The document provides examples of exception handling code in Java.
- Java inner classes are classes declared within other classes or interfaces. They allow grouping of logically related classes and interfaces and can access all members of the outer class, including private ones.
- There are three main advantages of inner classes: they can access private members of the outer class, they make code more readable by grouping related classes, and they require less code.
- The two types of inner classes are non-static (inner) classes and static nested classes. Non-static classes can access outer class members like private variables while static classes cannot access non-static members only static ones.
- Examples demonstrate member inner classes, anonymous inner classes, local inner classes, and static nested classes in Java and how they can
Introduction to method overloading & method overriding in java hdmHarshal Misalkar
This document introduces method overloading and method overriding in Java. Method overloading allows a class to have multiple methods with the same name but different parameters. It increases readability. Method overriding allows a subclass to provide a specific implementation of a method declared in the parent class. It is used for runtime polymorphism where the method being called is determined by the object type. The document provides examples of method overloading by changing number/type of arguments and of method overriding where the subclass overrides the parent's display method.
Chapter 02: Classes Objects and Methods Java by Tushar B KuteTushar B Kute
The lecture was condcuted by Tushar B Kute at YCMOU, Nashik through VLC orgnanized by MSBTE. The contents can be found in book "Core Java Programming - A Practical Approach' by Laxmi Publications.
This document discusses inheritance in Java. It defines inheritance as allowing new classes to reuse properties of existing classes. There are different types of inheritance including single, multilevel, and hierarchical. Key concepts covered include defining subclasses using the extends keyword, using the super keyword to call parent constructors and access parent members, overriding methods, abstract classes and methods, and using the final keyword to prevent overriding or inheritance.
This document discusses classes, objects, and methods in Java. It defines a class as a user-defined data type that contains fields and methods. Objects are instances of classes that allocate memory at runtime. Methods define behaviors for objects and are declared within classes. The document covers defining classes, creating objects, accessing members, constructors, method overloading and overriding, static members, passing objects as parameters, recursion, and visibility control.
Here, class PQR contains an object of class ABC as its data member. So class PQR contains class ABC through object ob1. This is an example of containership relationship between classes in OOP.
Streams are used to transfer data between a program and source/destination. They transfer data independently of the source/destination. Streams are classified as input or output streams depending on the direction of data transfer, and as byte or character streams depending on how the data is carried. Common stream classes in Java include FileInputStream, FileOutputStream, FileReader, and FileWriter for reading from and writing to files. Exceptions like FileNotFoundException may occur if a file cannot be opened.
This document provides an overview of basic object-oriented programming (OOP) concepts including objects, classes, inheritance, polymorphism, encapsulation, and data abstraction. It defines objects as entities with both data (characteristics) and behavior (operations). Classes are blueprints that are used to create objects. Inheritance allows objects to inherit properties from parent classes. Polymorphism allows code to take different forms. Encapsulation wraps data and functions into classes, hiding information. Data abstraction focuses on important descriptions without details.
Constructor is a special member method which will be called automatically when you create an object of any class.
The main purpose of using constructor is to initialize an object.
http://www.tutorial4us.com/java/java-constructor
This document provides an overview of client-server networking concepts in Java. It discusses elements like network basics, ports and sockets. It explains how to implement both TCP and UDP clients and servers in Java using socket classes. Sample code is provided for an echo client-server application using TCP and a quote client-server application using UDP. Exception handling for sockets is also demonstrated.
In this you learn about
--Constructors in Java
--Types of Constructors
1. Default Constructor
2. Parameterized Constructor
Difference between Constructor and Method
Java is a general-purpose computer-programming language that is concurrent, class-based, object-oriented,[15] and specifically designed to have as few implementation dependencies as possible
Type casting involves assigning a value of one data type to a variable of another type. There are two types of casting: widening (implicit) and narrowing (explicit). Widening casting converts data to a broader type without needing explicit casting, like converting an int to a long. Narrowing casting converts to a narrower data type and requires explicit casting, such as converting a double to a long.
This document discusses key object-oriented programming concepts in Java including inheritance, interfaces, polymorphism, and method overriding. It provides examples of how subclasses inherit fields and methods from parent classes, how to call parent class constructors, and how child class methods can override parent class methods of the same signature. The document also covers how interfaces define public abstract methods and variables, and how classes implement interfaces by overriding interface methods.
This document discusses key object-oriented programming concepts in Java including inheritance, interfaces, polymorphism, and method overriding. It provides examples of how subclasses inherit fields and methods from parent classes, how to call parent class constructors, and how child class methods can override parent class methods of the same signature. The document also covers how interfaces define public abstract methods and variables, and how classes implement interfaces by overriding interface methods.
- Inheritance is a mechanism where a derived class inherits properties from a base class. The derived class can have additional properties as well.
- The base class is called the parent/super class and the derived class is called the child/sub class. The subclass inherits all non-private fields and methods from the parent class.
- Key benefits of inheritance include code reusability, extensibility, data hiding and method overriding. Inheritance promotes software reuse by allowing subclasses to reuse code from the parent class.
This document discusses inheritance in Java. It defines inheritance as a mechanism where a subclass inherits the properties and behaviors of its parent class. It provides an example of single inheritance in Java where class B extends class A, inheriting its attributes and methods. The document also describes different types of inheritance like multilevel inheritance where a class inherits from another subclass, and hierarchical inheritance where a parent class has multiple subclasses. It provides an example of inheritance between different animal classes to demonstrate these concepts.
This document discusses different types of inheritance in object-oriented programming including single, multiple, multilevel, hierarchical, and hybrid inheritance. It provides syntax examples and code samples to illustrate each type of inheritance. Key points made include that single inheritance allows a derived class to inherit from one base class, multiple inheritance allows a class to inherit from more than one parent class, and hybrid inheritance combines two or more inheritance types.
The document discusses inheritance in object-oriented programming. It defines inheritance as a class acquiring the properties and methods of another class. Inheritance provides code reusability so that a class only needs to define unique features and can inherit common features from a parent class. Child classes extend and inherit from parent classes. The extends keyword is used to inherit from a parent class.
1. Inheritance allows classes to reuse properties of existing classes by extending them, making the extended class a subclass and the original class the superclass.
2. A subclass inherits and can access all public and protected properties of its superclass but can also define its own properties.
3. The subclass constructor must call the superclass constructor either implicitly or explicitly using the super() method.
oops(object oriented programing ) is introduced in c++ to enhance the 'c' programming. oops concept includes many important concepts like class,objects,abstraction,encapsulation,inheritance etc.
This document discusses the concept of inheritance in object-oriented programming. It defines inheritance as a technique for creating new classes from existing classes where the new class inherits properties and behaviors from the existing or parent class. It then describes three types of inheritance: single inheritance where a class inherits from one parent class, multi-level inheritance where a class inherits from another derived class, and multiple inheritance where a class can inherit from more than one parent class. Examples are provided for each type of inheritance to illustrate the concept.
This document discusses types of inheritance in object-oriented programming including single, multilevel, multiple, hierarchical, and hybrid inheritance. It provides code examples and explanations of:
- Single, multilevel, multiple, hierarchical, and hybrid inheritance structures
- Access specifiers for base and derived classes and their effects
- Calling base class constructors from derived class constructors
- The virtual keyword and dynamic binding in inheritance
The document contains code examples demonstrating inheritance concepts like defining base and derived classes, accessing members of base classes, and calling base class constructors from derived classes. It also provides explanations of multilevel, multiple, and hybrid inheritance with diagrams.
Object Oriented Programming_Chapter 3 (Two Lectures)
1- Let’s think on Inheritance
2- Let’s focus on Superclass’s Constructor
الكلية الجامعية للعلوم والتكنولوجيا - خان يونس
University college of science & technology
Inheritance allows a subclass to inherit properties and methods from a superclass. There are several types of inheritance in Java including single, multilevel, hierarchical, and hybrid inheritance. Single inheritance involves a subclass extending one superclass. Multilevel inheritance allows a subclass to inherit from another subclass. Hierarchical inheritance has one superclass with multiple subclasses. Hybrid inheritance combines single and multiple inheritance by implementing interfaces.
Inheritance allows classes to inherit attributes and methods from other classes. The class inheriting is called the derived class or subclass, while the class being inherited from is called the base class or superclass. This allows code reuse and prevents duplicating code across classes that share common attributes and methods. The document provides examples of single, multilevel, and hierarchical inheritance in Java using the superclass-subclass relationship between classes.
This document discusses inheritance in C++. It defines inheritance as a capability of a class to derive properties and characteristics from another class. There are different types of inheritance in C++ including single, multiple, multilevel, hierarchical and hybrid inheritance. It provides examples and explains the implementation of inheritance in C++ including access specifiers, constructor calls and resolving ambiguities.
This document discusses different types of inheritance in Java including single, hierarchical, multi-level, multiple and hybrid inheritance. It defines inheritance as a functionality that allows classes to extend other classes, inheriting their attributes and behaviors. Single inheritance involves one class extending another, hierarchical involves one base class extended by multiple classes, and multi-level involves extending classes that themselves extend other classes. The document notes that multiple inheritance is not supported in Java and provides examples to illustrate each inheritance type.
The document discusses inheritance in object-oriented programming. It covers the different types of inheritance like single, multiple, and multilevel inheritance. It explains the concepts of base/parent class and derived/child class. It provides examples of single, multiple, and multilevel inheritance with classes. It also discusses the different access specifiers for inheritance like public, private, and protected inheritance and how they control access to members of the parent class.
This document discusses Java inheritance including composition vs inheritance, inheritance definitions, types of inheritance (single, multilevel, hierarchical), why multiple inheritance is not supported, the super keyword and its uses, method overriding rules and examples. It defines inheritance as a parent-child relationship between classes that allows code and method reuse/overriding. Composition exhibits a "has-a" relationship while inheritance exhibits an "is-a" relationship. The super keyword can be used to access parent class members and call parent class methods/constructors. Method overriding provides a specific implementation of a method already in the parent class.
Inheritance allows new classes called derived classes to inherit properties from existing classes called base classes. There are different types of inheritance including single, multi-level, multiple, and hierarchical. Inheritance promotes code reusability and faster development. Derived classes inherit all features of the base class and can add new features. Constructors must be defined in derived classes to pass parameters to base class constructors. Abstract classes are designed only to act as base classes to be inherited by other classes.
Detailed presentation on Inheritance and interfaces in JAVA. Presentation includes suitable example for better understanding the concepts such as Overriding in java and also keywords such as FINAL and SUPER.
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...PECB
Denis is a dynamic and results-driven Chief Information Officer (CIO) with a distinguished career spanning information systems analysis and technical project management. With a proven track record of spearheading the design and delivery of cutting-edge Information Management solutions, he has consistently elevated business operations, streamlined reporting functions, and maximized process efficiency.
Certified as an ISO/IEC 27001: Information Security Management Systems (ISMS) Lead Implementer, Data Protection Officer, and Cyber Risks Analyst, Denis brings a heightened focus on data security, privacy, and cyber resilience to every endeavor.
His expertise extends across a diverse spectrum of reporting, database, and web development applications, underpinned by an exceptional grasp of data storage and virtualization technologies. His proficiency in application testing, database administration, and data cleansing ensures seamless execution of complex projects.
What sets Denis apart is his comprehensive understanding of Business and Systems Analysis technologies, honed through involvement in all phases of the Software Development Lifecycle (SDLC). From meticulous requirements gathering to precise analysis, innovative design, rigorous development, thorough testing, and successful implementation, he has consistently delivered exceptional results.
Throughout his career, he has taken on multifaceted roles, from leading technical project management teams to owning solutions that drive operational excellence. His conscientious and proactive approach is unwavering, whether he is working independently or collaboratively within a team. His ability to connect with colleagues on a personal level underscores his commitment to fostering a harmonious and productive workplace environment.
Date: May 29, 2024
Tags: Information Security, ISO/IEC 27001, ISO/IEC 42001, Artificial Intelligence, GDPR
-------------------------------------------------------------------------------
Find out more about ISO training and certification services
Training: ISO/IEC 27001 Information Security Management System - EN | PECB
ISO/IEC 42001 Artificial Intelligence Management System - EN | PECB
General Data Protection Regulation (GDPR) - Training Courses - EN | PECB
Webinars: https://pecb.com/webinars
Article: https://pecb.com/article
-------------------------------------------------------------------------------
For more information about PECB:
Website: https://pecb.com/
LinkedIn: https://www.linkedin.com/company/pecb/
Facebook: https://www.facebook.com/PECBInternational/
Slideshare: http://www.slideshare.net/PECBCERTIFICATION
Chapter wise All Notes of First year Basic Civil Engineering.pptxDenish Jangid
Chapter wise All Notes of First year Basic Civil Engineering
Syllabus
Chapter-1
Introduction to objective, scope and outcome the subject
Chapter 2
Introduction: Scope and Specialization of Civil Engineering, Role of civil Engineer in Society, Impact of infrastructural development on economy of country.
Chapter 3
Surveying: Object Principles & Types of Surveying; Site Plans, Plans & Maps; Scales & Unit of different Measurements.
Linear Measurements: Instruments used. Linear Measurement by Tape, Ranging out Survey Lines and overcoming Obstructions; Measurements on sloping ground; Tape corrections, conventional symbols. Angular Measurements: Instruments used; Introduction to Compass Surveying, Bearings and Longitude & Latitude of a Line, Introduction to total station.
Levelling: Instrument used Object of levelling, Methods of levelling in brief, and Contour maps.
Chapter 4
Buildings: Selection of site for Buildings, Layout of Building Plan, Types of buildings, Plinth area, carpet area, floor space index, Introduction to building byelaws, concept of sun light & ventilation. Components of Buildings & their functions, Basic concept of R.C.C., Introduction to types of foundation
Chapter 5
Transportation: Introduction to Transportation Engineering; Traffic and Road Safety: Types and Characteristics of Various Modes of Transportation; Various Road Traffic Signs, Causes of Accidents and Road Safety Measures.
Chapter 6
Environmental Engineering: Environmental Pollution, Environmental Acts and Regulations, Functional Concepts of Ecology, Basics of Species, Biodiversity, Ecosystem, Hydrological Cycle; Chemical Cycles: Carbon, Nitrogen & Phosphorus; Energy Flow in Ecosystems.
Water Pollution: Water Quality standards, Introduction to Treatment & Disposal of Waste Water. Reuse and Saving of Water, Rain Water Harvesting. Solid Waste Management: Classification of Solid Waste, Collection, Transportation and Disposal of Solid. Recycling of Solid Waste: Energy Recovery, Sanitary Landfill, On-Site Sanitation. Air & Noise Pollution: Primary and Secondary air pollutants, Harmful effects of Air Pollution, Control of Air Pollution. . Noise Pollution Harmful Effects of noise pollution, control of noise pollution, Global warming & Climate Change, Ozone depletion, Greenhouse effect
Text Books:
1. Palancharmy, Basic Civil Engineering, McGraw Hill publishers.
2. Satheesh Gopi, Basic Civil Engineering, Pearson Publishers.
3. Ketki Rangwala Dalal, Essentials of Civil Engineering, Charotar Publishing House.
4. BCP, Surveying volume 1
How to Setup Warehouse & Location in Odoo 17 InventoryCeline George
In this slide, we'll explore how to set up warehouses and locations in Odoo 17 Inventory. This will help us manage our stock effectively, track inventory levels, and streamline warehouse operations.
This presentation was provided by Racquel Jemison, Ph.D., Christina MacLaughlin, Ph.D., and Paulomi Majumder. Ph.D., all of the American Chemical Society, for the second session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session Two: 'Expanding Pathways to Publishing Careers,' was held June 13, 2024.
2. What is Inheritance
Inheritance is a
process by which
one class
acquires the
properties (fields
and methods) of
another class
3. Inheritance
Top class in know as a parent or base
class or super class
Class inheriting features is known as
child class, sub class
Inheritance is “IS A” relationship
between base and child class.
4. Syntax of Inheritance
class ChildClass
extends BaseClass{
}
class Studnet extends Person{
}
class Professor extends Person{
}
5. Types of Inheritance
Single level Inheritance
Multi-level Inheritance
Hierarchical Inheritance
Hybrid Inheritance
7. Single level Inheritance
Example
class A {
int a = 7;
}
class B extends A {
int b = 10;
}
public class TestIn1 {
public static void main(String[] s) {
B obj = new B();
System.out.println("values are a="
+ obj.a + " b=" + obj.b);
}
}
8. Multi level Inheritance
One class inherits the properties of another
class.
One more class inherits the properties of
inherited class
9. Multi level Inheritance
Example
class A {
int a = 7;
}
class B extends A {
int b = 10;
}
class C extends B {
int c = 12;
}
public class TestIn2 {
public static void main(String[] s) {
C obj = new C();
System.out.println("values are a=" + obj.a + "
b=" + obj.b + " c=" + obj.c);
}
}
11. Hierarchical Inheritance
Example
class A {
int a = 7;
}
class B extends A {
int b = 10;
}
class C extends A {
int c = 12;
}
public class TestIn3 {
public static void main(String[] s) {
B objB = new B();
System.out.println("values are a=" + objB.a + " b=" + objB.b);
C objC = new C();
System.out.println("values are a=" + objC.a + " c=" + objC.c);
}
}
13. Hybrid Inheritance Example
class A {
int a = 7;
void display() {
System.out.println("values are a=" + a);
}
}
class B extends A {
int b = 10;
}
class C extends A {
int c = 12;
}
class D extends B {
int d = 15;
}
public class TestIn4 {
public static void main(String[] s) {
D objD = new D();
System.out.println("values are a=" + objD.a + " b=" + objD.b + " d=" + objD.d);
objD.display();
C objC = new C();
System.out.println("values are a=" + objC.a + " c=" + objC.c);
}
}