oop java introduction object oriented programming java
Denna videohandledning introducerar OOP-koncept (Object Oriented Programming) i Java som Object, Class, Inheritance, Polymorphism, Abstraction, Encapsulation, etc:
Inom programvaruprogrammering har vi olika typer av programmeringsspråk. Stora språk bland dem är antingen processuella eller objektorienterade.
I processuella programmeringsspråk bryts större problem upp i små lösbara problem. Dessa små problem omvandlas till procedurer eller funktioner. På det här sättet betonar procedurprogrammeringsspråket funktioner snarare än data. Således har processspråk försummat data helt och därmed garanterar de inte datasäkerhet alls.
Detta problem hanterades av objektorienterat programmeringsspråk. Objektorienterad programmering är ett sätt att designa och programmera programvara genom att manipulera objekt och objekten är huvuddelen av programmeringen.
Upptäck hela vår serie Java-handledning för nybörjare här .
Vad du kommer att lära dig:
Videohandledning om OOPS-koncept
OOPS-koncept i Java - Del 1:
Fördjupad titt på OOPS Concept i Java - Del 2:
Objektorienterade programmeringsspråk betonar mer än bara funktionerna. Den objektorienterade programmeringen (OOP) kretsar kring objekt, dvs. en realtidsenhet.
Detta objekt samlar ihop data och metoderna som fungerar på dessa data i en enhet. På så sätt skyddas data från omvärlden genom att ha metoderna inuti objektet. I OOP kommunicerar objekten med varandra via meddelanden.
Alla OOP-språk stöder följande funktioner:
- Klasser
- Inkapsling
- Abstraktion
- Arv
- Polymorfism
Alla dessa funktioner säkerställer att data skyddas och samtidigt kan vi också skriva robusta applikationer. Smalltalk, C ++, Java, etc är några av de objektorienterade programmeringsspråken.
I denna handledning kommer vi att diskutera grunderna i OOP angående Java-språk.
Objektorienterad programmering (OOP) i Java
Java är den mest eftertraktade programmeringsförmågan för närvarande. I Java är allt baserat på objektet. Java har en rotklass som heter Objekt från vilken hela Java-funktionen härrör. Således i denna handledning kommer vi att diskutera de viktigaste funktionerna i OOP angående Java.
Rekommenderad läsning => OOP-intervjufrågor och svar
Här ska vi diskutera hur Java stöder följande OOP-funktioner.
- Objekt & klass
- Klass
- Arv
- Polymorfism
- Abstraktion
- Inkapsling
Låt oss diskutera vart och ett av dessa Java OOP-koncept i detalj.
Objekt & klass
En klass kan definieras som en designprototyp eller en ritning. Objekt skapas från dessa ritningar. Den definierar i huvudsak en vanlig typ som består av egenskaper och metoder som fungerar på dessa egenskaper för denna vanliga typ. Sedan definierar vi förekomsten av denna klass som kallas objekt.
En klass har många komponenter som visas i följande bild.
Ett objekt representerar en verklig enhet. I Java är ett objekt en förekomst av en klass. Så en klass som är en ritning kan användas för att skapa många objekt. Dessa objekt kommunicerar ofta med varandra genom att skicka meddelanden till varandra genom metoder.
Videohandledning: Klasser och objekt
Ett objekt har vanligtvis:
- Ett tillstånd: Objektets egenskaper eller attribut vid en viss tidpunkt.
- Beteende: Metoder representerar ett objekts beteende. Metoder definierar också hur objekten kommunicerar.
- Identitet: Identifierar objektet genom att ge det ett unikt namn.
Till exempel, om vi har en klass PetAnimals.
Sedan kan vi definiera ett objekt av denna klass enligt följande:
PetAnimals gris = nya PetAnimals.
Här är objektets identitet en gris.
Nedan följer ett program som visar klass och objekt.
//student class class Student{ int roll_No; String student_name; } class Main{ public static void main(String args()){ //Create objects of class Student Student student1=new Student(); Student student2=new Student(); //Initialize Student class objects student1.roll_No=101; student1.student_name='Lisa'; student2.roll_No=102; student2.student_name='Dan'; //Print object data System.out.println('Student 1 Details: ' + student1.roll_No+' '+student1.student_name); System.out.println('Student 2 Details: ' + student2.roll_No+' '+student2.student_name); } } Produktion
I ovanstående klass har vi definierat en klass Student med två egenskaper roll_No och student_name. Sedan i huvudmetoden deklarerar vi två klassobjekt, dvs student1 och student2. Observera att dessa objekt skapas med en ny operatör. När objekten har skapats tilldelar vi data till båda objektegenskaperna.
Slutligen skriver vi ut objektets innehåll med hjälp av '.' (Punkt) -operatören.
Vi kommer att lära oss mer om klasser och objekt i våra specifika OOP-handledningstema.
Arv
Arv är en av de viktigaste egenskaperna hos OOP. Genom arv främjar Java återanvändbarhet av kod.
Så vad är ett arv i Java?
Arv är en mekanism i Java där en klass kan ärva egenskaperna för en annan klass. Egenskaperna som kan ärvas inkluderar datamedlemmar och metoder i klassen.
Klassen som ärver egenskaperna för en annan klass kallas underklassen. Den ärvda klassen är känd som 'super' -klassen i Java.
Genom att ärva klassen ärver underklassen inte bara egenskaperna utan återanvänder också koden eftersom programmeraren inte en gång behöver skriva koden när den kan ärva den direkt med arv.
I Java uppnås arv med hjälp av nyckelordet 'extends'. Detta utökade nyckelord används i definitionen av klassen och följs av det klassnamn som ska ärvas.
Till exempel,om det finns två klasser, A och B och A ska ärvas av B, skrivs detta arv i Java som:
class B extends A { …… }Som redan nämnts är A här superklassen eller basklassen eller föräldraklassen. B är en underklass, härledd klass eller barnklass.
Arv delas vidare upp i följande typer.
Java stöder enstaka, flera nivåer och hierarkiska arv.
Observera att Java inte stöder flera arv. Java stöder inte heller hybridärv som är en kombination av flera och hierarkiska arv.
Nedan ges ett exempel på ett program för Single Inheritance in Java.
//base class class Employee{ float salary=50000; } //derived class class Developer extends Employee{ int bonus=20000; } class Main{ public static void main(String args()){ //declare Developer class object and access properties of base and derived class Developer p=new Developer(); System.out.println('Inheritance in Java'); System.out.println('Developer salary: '+p.salary); System.out.println('Bonus declared for Developer: '+p.bonus); System.out.println('Developer Total Earnings: ' + (p.salary + p.bonus)); } } Produktion
I ovanstående program har vi en basklass anställd. Vi har en annan klassutvecklare som ärver från medarbetarklassen. I huvudmetoden kan vi se att genom att förklara ett objekt för utvecklarklassen kan vi inte bara komma åt egenskaperna för utvecklarklassen utan även för anställdklassen eftersom det ärvs av utvecklarklassen.
Polymorfism
Polymorfism är ännu ett viktigt inslag i OOP. Polymorfism är språkets förmåga att tillåta objekt eller enheter att anta flera former. Till exempel, en metod som har olika implementeringar är polymorf i Java.
Polymorfism är av två typer i Java:
- Överbelastning eller kompilering av tidspolymorfism: Vid sammanställningstidspolymorfism löses uppmaningen till den polymorfa eller överbelastade metoden vid sammanställningstidpunkten.
- Överstyrande eller körtidspolymorfism: Vid körningspolymorfism löses uppmaningen till en åsidosatt metod i Java-programmet vid körning.
Vi kommer att diskutera polymorfism i detalj i våra efterföljande handledning.
Nedan följer ett exempel på kompileringstidspolymorfism i Java där vi har metodadd som är överbelastad för att utföra addition med olika operandtyper.
class Numbers_Sum { //add method : takes two int parameters public int add(int val1, int val2) { return (val1 + val2); } // overloaded add : takes three int parameters public int add(int val1, int val2, int val3) { return (val1 + val2 + val3); } //overloaded add: takes two double parameters public double add(double val1, double val2) { return (val1 + val2); } } class Main{ public static void main(String args()) { //create an object of Numbers_Sum class and call overloaded functions Numbers_Sum numsum = new Numbers_Sum(); System.out.println('Polymorphism in Java'); System.out.println('add(int, int): ' + numsum.add(15, 18)); System.out.println('add(int, int, int): ' + numsum.add(5, 10, 20)); System.out.println('add(double,double): ' + numsum.add(5.5, 15.5)); } }Produktion
I det här programmet har vi tre överbelastade metoder som heter add. Den första metoden tar två int-parametrar, nästa metod tar tre int-parametrar och den tredje metoden tar två dubbla parametrar. Beroende på antalet parametrar löses metodanropet vid sammanställningstid och lämpligt samtal görs.
Abstraktion
Med hjälp av dataabstraktion exponerar vi bara de väsentliga delarna av applikationen som görs tillgängliga för användaren. Till exempel, om vi har en bil är vi inte bekymrade över de interna komponenterna i bilen, utan vi betraktar bara bilen som en helhet.
Med hjälp av en dataabstraktionsmekanism identifierar vi bara nödvändiga detaljer och ignorerar de irrelevanta detaljerna. Java använder abstrakta klasser och gränssnitt för att uppnå abstraktion. Gränssnitt är 100% abstrakta eftersom de bara har metodprototyper och inte deras definition.
Nedanstående exempel visar en abstrakt klass och dess användning.
// Abstract class declaration abstract class PetAnimal { // Abstract method: should be defined in derived class public abstract void animalSound(); // non-abstract method public void print() { System.out.println('This method is example of abstraction'); } } // Derived class class Dog extends PetAnimal { //abstract method defined here public void animalSound() { System.out.println('The doggy barks'); } } class Main { public static void main(String() args) { Dog doggy = new Dog(); // Instantiate derived class and call methods doggy.animalSound(); doggy.print(); } }Produktion
I programmet ovan har vi en abstrakt klass PetAnimals. I detta har vi en abstrakt metod ”animalSound”. Sedan skapar vi en hundklass och ärver PetAnimals-klassen. I hundklassen åsidosätter vi metoden animalSound.
gratis popup-blockerare för krom
Inkapsling
Inkapsling döljer data eller skyddar data. Vid programmering uppnår vi inkapsling genom att slå in data och metoder som fungerar på dessa data under en enda enhet.
Videohandledning: Inkapsling och polymorfism i Java
En klass kan ses som en inkapslingsenhet, dvs vi har datamedlemmar och metoder som fungerar på dessa datalement som samlade i en enda enhet.
Korrekt inkapsling kan uppnås genom att göra datamedlemmar privata och ha metoderna som fungerar på dessa data som offentliga så att data är helt skyddade från externa enheter.
Nedanstående Java-program visar inkapslingskonceptet.
class Customer_Account { //private data of class private long customer_accountNo; private String customer_name,customer_email; private float customer_salary; //public getter/setter methods to access private data public long getAcc_no() { return customer_accountNo; } public void setAcc_no(long acc_no) { this.customer_accountNo = acc_no; } public String getName() { return customer_name; } public void setName(String name) { this.customer_name = name; } public String getEmail() { return customer_email; } public void setEmail(String email) { this.customer_email = email; } public float getSalary() { return customer_salary; } public void setSalary(float salary) { this.customer_salary = salary; } } public class Main { public static void main(String() args) { //create an object of customer_Account class Customer_Account acc=new Customer_Account(); //use setter methods to set values acc.setAcc_no(123458765432L); acc.setName('SoftwareTestingHelp'); acc.setEmail('sth@sth.com'); acc.setSalary(65000f); //use getter methods to read values System.out.println('Customer Account Number: ' + acc.getAcc_no()); System.out.println('Customer Account Details:'); System.out.println(' Customer Name: '+acc.getName()+'
'+ ' Customer Email: ' + acc.getEmail()+'
' + ' Customer Salary: ' +acc.getSalary()); } } Produktion
I ovanstående program har vi en klass Customer_Account.
I den här klassen har vi datamedlemmar som alla är privata. Sedan tillhandahåller vi getter- och settermetoder för varje privat fält för att läsa respektive ställa in värden. Dessa getters och setters är offentliga. På det här sättet skyddar vi datafälten genom att inte tillåta dem någon åtkomst utanför klassen direkt.
De kan endast nås via getters och setters. Detta visar inkapslingen som vi beskrev ovan.
Vanliga frågor
F # 1) Vad menas med objektorienterad programmering?
Svar: Objektorienterad programmering (OOP) är ett programvaruparadigm som kretsar kring data. I OOP läggs tonvikten på data och därmed uttrycks problemen i termer av objekt som är enheter som består av data eller fält och metoder som fungerar på dessa datafält.
Genom att göra detta används flera kännetecken för OOP som arv, polymorfism, abstraktion och inkapsling för att säkerställa datasäkerhet, återanvändning etc.
F # 2) Vilka är de fyra grundläggande principerna för OOP?
Svar:Objektorienterad programmering (OOP) har fyra grundläggande principer:
- Arv
- Polymorfism
- Abstraktion
- Inkapsling
De kallas också fyra pelare i OOP.
F # 3) Varför kallas Java för Object-Oriented?
Svar: Java har ett rotklassobjekt som vi härleder alla andra funktioner i Java. Således utan klass och objekt kan vi inte ha ett Java-program. Därför kallas Java OOP-språk.
F # 4) Är Java rent objektorienterat?
Svar: Nej, Java är inte ett rent objektorienterat språk. Eftersom Java också tillhandahåller primitiva datatyper som int, char, float, double, long, etc. klassificeras det inte som ett rent OOP-språk.
F # 5) Vad är skillnaden mellan C ++ och Java?
Svar: Både C ++ och Java är objektorienterade språk och stöder OOP-funktioner. Men C ++ är ett sammanställt språk. Java är å andra sidan sammanställt såväl som ett tolkat språk.
Java-tolken kör byte-koden vid körning och genererar utdata som gör den plattformsoberoende. C ++ är dock plattformberoende.
Mer om OOPS Concept
Klass
Klassen är en ritning / prototyp av ett verkligt objekt och den modellerar tillståndet och beteendet hos det verkliga objektet.
Klassdeklaration
class MyClass { // field, constructor, and // method declarations } Class room(){ //room should have dimension. Dimension is attribute. //in the room, we are going keep things. Keeping is the function we are going to do. Keepthings (); this is a method in java. } 
Objekt
Programvaruobjekt är som verkliga objekt med tillstånd och beteende. Staten kommer att lagras som ett fält och exponera dess beteende som metoder.
Här är rummet som allmän design. Inom detta rum ska du utforma ett vardagsrum, matrum, sovrum.
Class CookingRoom(){ Dimension is attribute. //here we should have method to keep cooking things. Keepthings(){ This method is same like room class keep things method. but it should have some more features to hold cooking items. } cooking(); } Class LivingRoom(){ Dimension is attribute. //here we should have method to keep Living Room things. Keepthings(){ This method is same like room class keep things method. but it should have some more features to hold living room items(like tv etc). } watching tv(); } Här bör 'Keepthings ()' -metoden utföra de grundläggande funktionerna som krävs för rummet och den bör ha ytterligare specifikationer enligt klass 'vardagsrum' och 'matlagningsrum'. Så de två klasserna bör ärva metoderna i 'rum' -klassen.
Arv
Beteende (metoder) och tillstånd för en klass som ärvs till den andra klassen kallas arv. Metoderna och tillståndet ärvs från föräldraklassen till barnklassen.
Så,
Class CookingRoom extends Room{ } Class LivingRoom extends Room{ }Polymorfism
I biologi hänvisar polymorfism till kryddor som kan ha många olika former.
Med samma koncept i objektorienterad programmering kan barnklassen ärva sina överordnade klassmetoder, det kan också lägga till unika funktioner i det beteendet. Polymorfism kan uppnås genom metodöverbelastning eller åsidosättande.
Överbelastning
public class OverloadDemo { public int add( int a,int b) { int rs=a+b; return rs; } public int add( int a,int b,int c) { int rs=a+b+c; return rs; } public static void main(String() args) { OverloadDemo ov=new OverloadDemo(); System.out.println(ov.add(23,56,45)); System.out.println(ov.add(23,56)); } } 
Åsidosättande
public class Bicycle { int wheels=2; String seat; public void riding() { System.out.println('bicycle is used for riding'); } } 
public class RoadBicycle extends Bicycle{ public void riding() { System.out.println('RoadBicycle is used for road riding'); } } 
public class TestBicycle { public static void main(String() args) { Bicycle b=new RoadBicycle(); b.riding(); } } 
PRODUKTION: Här åsidosätter barnklassmetoden överordnad klassmetod.
Super nyckelord
Super-nyckelord är en referensvariabel som används för att referera till det omedelbara klassobjektet. Med super-nyckelord kan du hänvisa till överordnad klassmetod eller variabler eller konstruktör.
Detta nyckelord
Detta nyckelord används för att referera till det aktuella klassobjektet. Med hjälp av detta nyckelord kan du komma åt den aktuella klassinstansvariabeln eller den aktuella klassmetoden. Detta kan skickas som ett argument i metodanropet.
public class DemoThisKeyword { private int accno; private int balance; public void setvalues(int accno,int balance) { this.accno=accno; this.balance=balance; } public int showdata() { System.out.println(accno); System.out.println(balance); return balance; } public static void main(String() args) { // TODO Auto-generated method stub DemoThisKeyword obj =new DemoThisKeyword(); obj.setvalues(11, 100); obj.showdata(); System.out.println(obj.showdata()); } } 
Byggare
Java-konstruktörer är som metoder som kommer att anropas när objektet skapas för klassen. Konstruktören ska ha samma namn som klassen.
Class Myclass{ Myclass(); Method1() { } } 
När du skapar ett objekt för klassen är Myclass myobj = new Myclass ();
Konstruktormetoden kommer att anropas. Konstruktören skapas automatiskt av Java-kompilatorn för alla klasser som standard.
public class ConstructorExampleProgram { int employee_age; String employee_name; int employee_salary; //Default constructor ConstructorExampleProgram(){ this.employee_name=Bob'; this.employee_age=30; this.employee_salary=7000; } //Parameterized constructor ConstructorExampleProgram(String n,int a,int b){ this.employee_name=n; this.employee_age=a; this.employee_salary=b; } public static void main(String args()){ ConstructorExampleProgram obj1 = new ConstructorExampleProgram(); ConstructorExampleProgram obj2 = new ConstructorExampleProgram('clare', 56,7500); System.out.println(obj1.employee_name+' '+obj1.employee_age+' '+obj1.employee_salary); System.out.println(obj2.employee_name+' '+obj2.employee_age+' '+obj2.employee_salary); } } 
Regler som ska följas för konstruktören:
- Konstruktören ska ha samma namn som klassnamnet.
- Konstruktören ska inte ha ett returuttalande.
Poäng att notera:
- I objektorienterad programmering är objekten den viktigaste delen av programmeringen.
- OOP-begrepp är objekt, klass, arv, polymorfism, konstruktör.
- Super nyckelord som används för att hänvisa till föräldraklassmedlemmarna och detta nyckelord används för att referera till ett aktuellt klassobjekt.
- Konstruktörer är som metoder som kommer att anropas när objektet skapas för klassen.
Slutsats
Denna handledning behandlade grunderna för viktiga objektorienterade funktioner som stöds av Java. Detta är bara en introduktionshandledning om OOPS i Java. Vi kommer att täcka alla ämnen i detalj i våra efterföljande handledning. Java stöder fyra pelare i OOP, dvs polymorfism, arv, abstraktion och inkapsling.
Förutom dessa funktioner stöder Java även andra funktioner och OOP-konstruktioner som inneslutning, aggregering, meddelandeöverföring etc. som kommer att diskuteras i våra kommande handledning.
Rekommenderad läsning
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Vad är abstraktion i Java - lär dig med exempel
- Vad är arv i Java - Handledning med exempel
- Vad är polymorfism i Java - Handledning med exempel
- Inkapsling i Java: Komplett handledning med exempel
- Typer av arv i Java - Single Vs Multiple Arv
- OOPS Concepts In C #: Object Oriented Programming Concept Tutorial
- Objektorienterad programmering i C ++