diff --git a/.idea/misc.xml b/.idea/misc.xml index 1b2d693..208e2c3 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,6 @@ - + \ No newline at end of file diff --git a/Java2.iml b/Java2.iml index c90834f..c3dc060 100644 --- a/Java2.iml +++ b/Java2.iml @@ -7,5 +7,15 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/Again/Bicycle.java b/src/Again/Bicycle.java new file mode 100644 index 0000000..d9c0d73 --- /dev/null +++ b/src/Again/Bicycle.java @@ -0,0 +1,23 @@ +package Again; + +public class Bicycle { + public int speed; + public int gear; + + public Bicycle(int speed, int gear) { + this.speed = speed; + this.gear = gear; + } + + public void changeGear(int newGear) { + gear = newGear; + } + + public void speedUp(int increment) { + speed += increment; + } + + public void applyBrake(int decrement) { + speed -= decrement; + } +} diff --git a/src/Again/Boat.java b/src/Again/Boat.java new file mode 100644 index 0000000..b09b44a --- /dev/null +++ b/src/Again/Boat.java @@ -0,0 +1,15 @@ +package Again; + +public class Boat { + public double length; + public double weight; + + public Boat(double length, double weight) { + this.length = length; + this.weight = weight; + } + + public void sail() { + System.out.println("The boat is sailing"); + } +} diff --git a/src/Again/Car.java b/src/Again/Car.java new file mode 100644 index 0000000..abf1925 --- /dev/null +++ b/src/Again/Car.java @@ -0,0 +1,25 @@ +package Again; + +public class Car { + public String make; + public String model; + public int year; + + public Car(String make, String model, int year) { + this.make = make; + this.model = model; + this.year = year; + } + + public void start() { + System.out.println("Car is starting"); + } + + public void stop() { + System.out.println("Car is stopping"); + } + + public void accelerate() { + System.out.println("Car is accelerating"); + } +} \ No newline at end of file diff --git a/src/Again/ElectricCar.java b/src/Again/ElectricCar.java new file mode 100644 index 0000000..00efb25 --- /dev/null +++ b/src/Again/ElectricCar.java @@ -0,0 +1,16 @@ +package Again; + +public class ElectricCar extends Car { + public int batteryCapacity; + public int range; + + public ElectricCar(String make, String model, int year, int batteryCapacity, int range) { + super(make, model, year); + this.batteryCapacity = batteryCapacity; + this.range = range; + } + + public void charge() { + System.out.println("Electric car is charging"); + } +} diff --git a/src/Again/FishingBoat.java b/src/Again/FishingBoat.java new file mode 100644 index 0000000..da8e18e --- /dev/null +++ b/src/Again/FishingBoat.java @@ -0,0 +1,16 @@ +package Again; + +public class FishingBoat extends Boat { + public int fishCapacity; + public String typeOfNet; + + public FishingBoat(double length, double weight, int fishCapacity, String typeOfNet) { + super(length, weight); + this.fishCapacity = fishCapacity; + this.typeOfNet = typeOfNet; + } + + public void castNet() { + System.out.println("Casting the net"); + } +} diff --git a/src/Again/Main.java b/src/Again/Main.java new file mode 100644 index 0000000..ade4114 --- /dev/null +++ b/src/Again/Main.java @@ -0,0 +1,56 @@ +package Again; + +public class Main { + public static void main(String[] args) { + Bicycle bike = new Bicycle(10, 1); + bike.speedUp(5); + bike.changeGear(2); + bike.applyBrake(2); + System.out.println("Bicycle speed: " + bike.speed + ", gear: " + bike.gear); + MountainBike mountainBike = new MountainBike(15, 3, "Off-road", "Full"); + mountainBike.speedUp(10); + mountainBike.adjustSuspension("Soft"); + System.out.println("MountainBike speed: " + mountainBike.speed + ", gear: " + mountainBike.gear + ", tire type: " + mountainBike.tireType + ", suspension: " + mountainBike.suspension); + + + Car car = new Car("Toyota", "Corolla", 2020); + car.start(); + car.accelerate(); + car.stop(); + System.out.println("Car make: " + car.make + ", model: " + car.model + ", year: " + car.year); + + ElectricCar electricCar = new ElectricCar("Tesla", "Model S", 2021, 100, 400); + electricCar.start(); + electricCar.charge(); + electricCar.accelerate(); + electricCar.stop(); + System.out.println("ElectricCar make: " + electricCar.make + ", model: " + electricCar.model + ", year: " + electricCar.year + ", battery capacity: " + electricCar.batteryCapacity + ", range: " + electricCar.range); + + Tesla tesla = new Tesla("Tesla", "Model X", 2022, 100, 350, "v10.2"); + tesla.start(); + tesla.enableAutopilot(); + tesla.accelerate(); + tesla.stop(); + System.out.println("Tesla make: " + tesla.make + ", model: " + tesla.model + ", year: " + tesla.year + ", battery capacity: " + tesla.batteryCapacity + ", range: " + tesla.range + ", autopilot version: " + tesla.autopilotVersion); + Boat boat = new Boat(30.5, 5000); + boat.sail(); + System.out.println("Boat length: " + boat.length + ", weight: " + boat.weight); + + SpeedBoat speedBoat = new SpeedBoat(25.0, 3000, 80, "V8"); + speedBoat.sail(); + speedBoat.turboBoost(); + System.out.println("SpeedBoat length: " + speedBoat.length + ", weight: " + speedBoat.weight + ", max speed: " + speedBoat.maxSpeed + ", engine type: " + speedBoat.engineType); + + FishingBoat fishingBoat = new FishingBoat(20.0, 4000, 1000, "Gillnet"); + fishingBoat.sail(); + fishingBoat.castNet(); + System.out.println("FishingBoat length: " + fishingBoat.length + ", weight: " + fishingBoat.weight + ", fish capacity: " + fishingBoat.fishCapacity + ", type of net: " + fishingBoat.typeOfNet); + } +} + + + + + + + diff --git a/src/Again/MountainBike.java b/src/Again/MountainBike.java new file mode 100644 index 0000000..4d40bd1 --- /dev/null +++ b/src/Again/MountainBike.java @@ -0,0 +1,17 @@ +package Again; + +public class MountainBike extends Bicycle { + public String tireType; + public String suspension; + + public MountainBike(int speed, int gear, String tireType, String suspension) { + super(speed, gear); + this.tireType = tireType; + this.suspension = suspension; + } + + public void adjustSuspension(String newSuspension) { + suspension = newSuspension; + } +} + diff --git a/src/Again/SpeedBoat.java b/src/Again/SpeedBoat.java new file mode 100644 index 0000000..e393526 --- /dev/null +++ b/src/Again/SpeedBoat.java @@ -0,0 +1,16 @@ +package Again; + +public class SpeedBoat extends Boat { + public int maxSpeed; + public String engineType; + + public SpeedBoat(double length, double weight, int maxSpeed, String engineType) { + super(length, weight); + this.maxSpeed = maxSpeed; + this.engineType = engineType; + } + + public void turboBoost() { + System.out.println("Turbo boost activated"); + } +} diff --git a/src/Again/Tesla.java b/src/Again/Tesla.java new file mode 100644 index 0000000..5444036 --- /dev/null +++ b/src/Again/Tesla.java @@ -0,0 +1,14 @@ +package Again; + +public class Tesla extends ElectricCar { + public String autopilotVersion; + + public Tesla(String make, String model, int year, int batteryCapacity, int range, String autopilotVersion) { + super(make, model, year, batteryCapacity, range); + this.autopilotVersion = autopilotVersion; + } + + public void enableAutopilot() { + System.out.println("Autopilot is enabled"); + } +} diff --git a/src/Homework/AnimalClass/Main.java b/src/Homework/AnimalClass/Mains.java similarity index 95% rename from src/Homework/AnimalClass/Main.java rename to src/Homework/AnimalClass/Mains.java index 1738744..2f7d4c1 100644 --- a/src/Homework/AnimalClass/Main.java +++ b/src/Homework/AnimalClass/Mains.java @@ -52,8 +52,8 @@ public String makeSound() { } } -public class Main { - public static void main(String[] args) { +public class Mains { + protected static void main(String[] args) { Animal dog = new Dog("Lucy", 3); Animal cat = new Cat("Luna", 4); Animal wolf = new Wolf("Bursuc", 5); diff --git a/src/Homework/MatrixMultiplication.java b/src/Homework/MatrixMultiplication.java new file mode 100644 index 0000000..869081b --- /dev/null +++ b/src/Homework/MatrixMultiplication.java @@ -0,0 +1,71 @@ +package Homework; + +import java.util.Arrays; + +public class MatrixMultiplication { + public static void main(String[] args) { + int size = 500; + double[][] A = generateRandomMatrix(size, size); + double[][] B = generateRandomMatrix(size, size); + double[][] C = new double[size][size]; + + int numThreads = 4; + Thread[] threads = new Thread[numThreads]; + int rowsPerThread = size / numThreads; + + for (int i = 0; i < numThreads; i++) { + int startRow = i * rowsPerThread; + int endRow = (i == numThreads - 1) ? size : startRow + rowsPerThread; + threads[i] = new Thread(new Worker(A, B, C, startRow, endRow)); + threads[i].start(); + } + + for (Thread thread : threads) { + try { + thread.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + System.out.println("Matrix multiplication completed."); + } + + private static double[][] generateRandomMatrix(int rows, int cols) { + double[][] matrix = new double[rows][cols]; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + matrix[i][j] = Math.random(); + } + } + return matrix; + } +} + +class Worker implements Runnable { + private final double[][] A; + private final double[][] B; + private final double[][] C; + private final int startRow; + private final int endRow; + + public Worker(double[][] A, double[][] B, double[][] C, int startRow, int endRow) { + this.A = A; + this.B = B; + this.C = C; + this.startRow = startRow; + this.endRow = endRow; + } + + @Override + public void run() { + for (int i = startRow; i < endRow; i++) { + for (int j = 0; j < B[0].length; j++) { + C[i][j] = 0; + for (int k = 0; k < A[0].length; k++) { + C[i][j] += A[i][k] * B[k][j]; + } + } + } + } +} diff --git a/src/Sesion_13_Polymorphism/Main.java b/src/Sesion_13_Polymorphism/Main.java new file mode 100644 index 0000000..96cc57c --- /dev/null +++ b/src/Sesion_13_Polymorphism/Main.java @@ -0,0 +1,81 @@ +package Sesion_13_Polymorphism; + +public class Main { + public static void main(String... args) { + Animal myAnimal = new Dog();//upcasting ->Animal + //myAnimal.makeSound(); + // myAnimal.sleep(); + + Dog myDog = (Dog) myAnimal;//downcasting Animal-> Dog + myDog.makeSound(5); + + // myDog.fetch(); + // myDog.makeSound(); + doAnimalStuff(myDog); + doAnimalStuff(new Cat()); + + try { + Cat myCat = (Cat) myAnimal; + myCat.makeSound(); + } catch (ClassCastException ex) { + System.out.println("Eroare.Nu putem face downcasting de la caine la pisica "); + } + } + + public static void doAnimalStuff(Animal animal) { + animal.makeSound(); + if (animal instanceof Dog) { + ((Dog) animal).fetch(); + } else if (animal instanceof Cat) { + ((Cat) animal).scratch(); + } + + } + + +} + + +//clasa parinte/superclasa +class Animal { + public void makeSound() { + System.out.println("Generic sound"); + + } + + + public void sleep() { + System.out.println("Sleep"); + } +} +//clasa derivata,(subclasa) + +class Dog extends Animal { + @Override + public void makeSound() { + System.out.println("Cainele face hamham"); + } + public void makeSound(int times) { + for (int i = 0; i < times; i++) + System.out.println("Cainele face ham ham"); + } + + public void fetch() { + System.out.println("cainele aduce mingea"); + } +} + +//clasa derivata/clasa copil/subclasa +class Cat extends Animal { + @Override + public void makeSound() { + System.out.println("pisica face miau miau"); + } +public void makeSound(int times){ +} + + public void scratch() { + System.out.println("pisica zgarie"); + } + +} diff --git a/src/Sesion_13_Polymorphism/PaymentSystem.java b/src/Sesion_13_Polymorphism/PaymentSystem.java new file mode 100644 index 0000000..8f9f8c9 --- /dev/null +++ b/src/Sesion_13_Polymorphism/PaymentSystem.java @@ -0,0 +1,119 @@ +package Sesion_13_Polymorphism; + + +//Interfata Payment defineste comportamentele comune pentru toate tipurile de plati +interface Payment { + void processPayment(double amount);//o metoda abstracta pentru procesarea platilor + + void showTransactionDetails(); + +} + +abstract class CardPayment implements Payment { + private String cardNumber; + private String cardHolderName; + + + public CardPayment(String cardNumber, String cardHolderName) { + this.cardNumber = cardNumber; + this.cardHolderName = cardHolderName; + } + + @Override + public void showTransactionDetails() { + System.out.println("Plata realizata cu cardul: " + cardHolderName + "(Card: " + maskCardNumber() + ")"); + + } + + private String maskCardNumber() { + return "**** **** **** " + cardNumber.substring(cardNumber.length() - 4); + + } + + public String getCardHolderName() { + return cardHolderName; + } + +} + +class CreditCardPayment extends CardPayment { + public CreditCardPayment(String cardNumber, String cardHolderName) { + super(cardNumber, cardHolderName); + } + + @Override + public void processPayment(double amount) { + System.out.println("Procesare plata card credit de : " + amount + "pentru " + super.getCardHolderName()); + } +} + +class DebitCardPayment extends CardPayment { + public DebitCardPayment(String cardNumber, String cardHolderName) { + super(cardNumber, cardHolderName); + } + + @Override + public void processPayment(double amount) { + System.out.println("Procesare plata card deb " + amount + "pentru " + super.getCardHolderName()); + } +} + +class BankTransfer implements Payment { + private String iban; + private String bankName; + + public BankTransfer(String iban, String bankName) { + this.iban = iban; + this.bankName = bankName; + } + + @Override + public void processPayment(double amount) { + System.out.println("TransferTransfer bancar de " + amount + "catre IBAN-ul " + iban + "la banca " + bankName); + } + + @Override + public void showTransactionDetails() { + System.out.println("Detalii transfer bancar : Iban " + iban + "Banca: " + bankName); + + } +} + +class CryptoPayment implements Payment { + private String walletAddress; + private String cryptoType; + + public CryptoPayment(String walletAddress, String cryptoType) { + this.cryptoType = cryptoType; + this.walletAddress = walletAddress; + } + + @Override + public void processPayment(double amount) { + System.out.println("Plata de " + amount + " " + cryptoType + " cartre adresa " + walletAddress); + } + + @Override + public void showTransactionDetails() { + System.out.println("Detali plata crypto: " + cryptoType + "wallet: " + walletAddress); + } +} + + +public class PaymentSystem { + public static void main(String... args) { + Payment creditCard = new CreditCardPayment("1234567812345678 ", " Ion Popescu "); + Payment debitCard = new DebitCardPayment("8765432187654321 ", " Maria ionescu "); + Payment bankTransfer = new BankTransfer("RO79btrlro76546789 ", " BT"); + Payment cryptoPayment = new CryptoPayment("ierujsdjf54h32545fh", "Bitcoin "); + + Payment[] payments = {creditCard,debitCard,bankTransfer,cryptoPayment}; + + for(Payment p : payments){ + p.processPayment( 100.0 ); + p.showTransactionDetails(); + System.out.println(); + } + + } +} diff --git a/src/Sesion_14_Recap_OPP/Main.java b/src/Sesion_14_Recap_OPP/Main.java new file mode 100644 index 0000000..bec79ef --- /dev/null +++ b/src/Sesion_14_Recap_OPP/Main.java @@ -0,0 +1,295 @@ +package Sesion_14_Recap_OPP; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.List; + +abstract class Item { + protected String titlu; + protected int anPublicare; + + public Item(String titlu, int anPublicare) { + this.titlu = titlu; + this.anPublicare = anPublicare; + } + + public String getTitlu() { + return titlu; + } + + public int getAnPublicare() { + return anPublicare; + } + + abstract public String getDetalii(); +} + +interface Imprumutabil { + void imprumuta(String numeCititor, LocalDate dataReturnare); + + void returneaza(); + + boolean esteDisponibil(); + + String getNumeCititor(); + + LocalDate getDataReturnare(); +} + +class Carte extends Item implements Imprumutabil { + private String autor; + private boolean disponibil; + private String numeCititor; + private LocalDate dataReturnare; + + public Carte(String titlu, String autor, int anPublicare) { + super(titlu, anPublicare); + this.autor = autor; + this.disponibil = true; + } + + public String getAutor() { + return autor; + } + + @Override + public String getDetalii() { + return "Carte: " + titlu + " de " + autor + " (" + anPublicare + ")"; + } + + @Override + public void imprumuta(String numeCititor, LocalDate dataReturnare) { + this.disponibil = false; + this.numeCititor = numeCititor; + this.dataReturnare = dataReturnare; + } + + @Override + public void returneaza() { + this.disponibil = true; + this.numeCititor = null; + this.dataReturnare = null; + } + + @Override + public boolean esteDisponibil() { + return disponibil; + } + + @Override + public String getNumeCititor() { + return numeCititor; + } + + @Override + public LocalDate getDataReturnare() { + return dataReturnare; + } +} + +class Revista extends Item implements Imprumutabil { + private int numarEditie; + private boolean disponibil; + private String numeCititor; + private LocalDate dataReturnare; + + public Revista(String titlu, int anPublicare, int numarEditie) { + super(titlu, anPublicare); + this.numarEditie = numarEditie; + this.disponibil = true; + } + + public int getNumarEditie() { + return numarEditie; + } + + @Override + public String getDetalii() { + return "Revista: " + titlu + " Nr. " + numarEditie + " (" + anPublicare + ")"; + } + + @Override + public void imprumuta(String numeCititor, LocalDate dataReturnare) { + this.disponibil = false; + this.numeCititor = numeCititor; + this.dataReturnare = dataReturnare; + } + + @Override + public void returneaza() { + this.disponibil = true; + this.numeCititor = null; + this.dataReturnare = null; + } + + @Override + public boolean esteDisponibil() { + return disponibil; + } + + @Override + public String getNumeCititor() { + return numeCititor; + } + + @Override + public LocalDate getDataReturnare() { + return dataReturnare; + } +} + +class Imprumut { + private Imprumutabil item; + private String numeCititor; + private LocalDate dataImprumut; + private LocalDate dataReturnare; + + public Imprumut(Imprumutabil item, String numeCititor, LocalDate dataReturnare) { + this.item = item; + this.numeCititor = numeCititor; + this.dataImprumut = LocalDate.now(); + this.dataReturnare = dataReturnare; + } + + public Imprumutabil getItem() { + return item; + } + + public String getNumeCititor() { + return numeCititor; + } + + public LocalDate getDataImprumut() { + return dataImprumut; + } + + public LocalDate getDataReturnare() { + return dataReturnare; + } + + @Override + public String toString() { + return "Împrumut: " + ((Item) item).getTitlu() + " de către " + numeCititor + + " (Împrumutat: " + dataImprumut + ", Returnare: " + dataReturnare + ")"; + } +} + +class Biblioteca { + private List items; + private List imprumuturi; + + public Biblioteca() { + this.items = new ArrayList<>(); + this.imprumuturi = new ArrayList<>(); + } + + public void adaugaItem(Item item) { + items.add(item); + } + + public void eliminaItem(Item item) { + items.remove(item); + } + + public Item cautaDupaTitlu(String titlu) { + for (Item item : items) { + if (item.getTitlu().equalsIgnoreCase(titlu)) { + return item; + } + } + return null; + } + + public List cautaDupaAutor(String autor) { + List rezultate = new ArrayList<>(); + for (Item item : items) { + if (item instanceof Carte && ((Carte) item).getAutor().equalsIgnoreCase(autor)) { + rezultate.add(item); + } + } + return rezultate; + } + + public void afiseazaToateElementele() { + for (Item item : items) { + System.out.println(item.getDetalii() + " - Disponibil: " + + (item instanceof Imprumutabil ? ((Imprumutabil) item).esteDisponibil() : "N/A")); + } + } + + public void imprumutaItem(Item item, String numeCititor, LocalDate dataReturnare) { + if (item instanceof Imprumutabil) { + Imprumutabil imprumutabil = (Imprumutabil) item; + if (imprumutabil.esteDisponibil()) { + imprumutabil.imprumuta(numeCititor, dataReturnare); + imprumuturi.add(new Imprumut(imprumutabil, numeCititor, dataReturnare)); + System.out.println("Item împrumutat cu succes: " + item.getTitlu()); + } else { + System.out.println("Item-ul nu este disponibil pentru împrumut: " + item.getTitlu()); + } + } else { + System.out.println("Acest item nu poate fi împrumutat: " + item.getTitlu()); + } + } + + public void returneazaItem(Item item) { + if (item instanceof Imprumutabil) { + Imprumutabil imprumutabil = (Imprumutabil) item; + if (!imprumutabil.esteDisponibil()) { + imprumutabil.returneaza(); + imprumuturi.removeIf(imprumut -> imprumut.getItem() == imprumutabil); + System.out.println("Item returnat cu succes: " + item.getTitlu()); + } else { + System.out.println("Acest item nu a fost împrumutat: " + item.getTitlu()); + } + } else { + System.out.println("Acest item nu poate fi returnat: " + item.getTitlu()); + } + } + + public void afiseazaImprumuturi() { + if (imprumuturi.isEmpty()) { + System.out.println("Nu există împrumuturi active."); + } else { + System.out.println("Împrumuturi active:"); + for (Imprumut imprumut : imprumuturi) { + System.out.println(imprumut); + } + } + } +} + +public class Main { + public static void main(String[] args) { + Biblioteca biblioteca = new Biblioteca(); + + Carte carte1 = new Carte("Mândrie și prejudecată", "Jane Austen", 1813); + Carte carte2 = new Carte("1984", "George Orwell", 1949); + Revista revista1 = new Revista("National Geographic", 2023, 1); + + biblioteca.adaugaItem(carte1); + biblioteca.adaugaItem(carte2); + biblioteca.adaugaItem(revista1); + + System.out.println("Toate elementele din bibliotecă:"); + biblioteca.afiseazaToateElementele(); + + System.out.println("\nÎmprumutarea cărții '1984':"); + biblioteca.imprumutaItem(carte2, "Ion Popescu", LocalDate.now().plusWeeks(2)); + + System.out.println("\nÎmprumutarea revistei 'National Geographic':"); + biblioteca.imprumutaItem(revista1, "Maria Ionescu", LocalDate.now().plusWeeks(1)); + + System.out.println("\nToate elementele după împrumut:"); + biblioteca.afiseazaToateElementele(); + + System.out.println("\nAfișarea împrumuturilor active:"); + biblioteca.afiseazaImprumuturi(); + + System.out.println("\nReturnarea cărții '1984':"); + biblioteca.returneazaItem(carte2); + + System.out.println("\nAfișarea împrumuturilor active după returnare:"); + biblioteca.afiseazaImprumuturi(); + } +} \ No newline at end of file diff --git a/src/Sesion_15_CollectionsFramework/ComparatorMunte.java b/src/Sesion_15_CollectionsFramework/ComparatorMunte.java new file mode 100644 index 0000000..f35cf37 --- /dev/null +++ b/src/Sesion_15_CollectionsFramework/ComparatorMunte.java @@ -0,0 +1,11 @@ +package Sesion_15_CollectionsFramework; + +import java.util.Comparator; + +public class ComparatorMunte implements Comparator { + + @Override + public int compare(Munte o1, Munte o2) { + return o1.getNume().compareTo(o2.getNume()); + } +} diff --git a/src/Sesion_15_CollectionsFramework/Main.java b/src/Sesion_15_CollectionsFramework/Main.java new file mode 100644 index 0000000..8653979 --- /dev/null +++ b/src/Sesion_15_CollectionsFramework/Main.java @@ -0,0 +1,42 @@ +package Sesion_15_CollectionsFramework; + +import java.util.*; + +public class Main { + public static void main(String[] args) { + List fructe = new ArrayList<>(Arrays.asList("mar", "banana", "portocala", "pruna")); + + for (String fruct : fructe) { + System.out.println(fruct); + // if(fruct.equals("banana")){ + // fructe.remove(fruct); + // } + } + + //itnterator + Iterator iterator = fructe.iterator(); + + while (iterator.hasNext()) { + String fruct = iterator.next(); + System.out.println("Fruct: " + fruct); + if (fruct.equals("banana")) { + iterator.remove(); + } + } + System.out.println("Lista dupa stergere: " + fructe); + + + List munti = new ArrayList<>(); + munti.add(new Munte("Everest", 8840)); + munti.add(new Munte("K2", 8644)); + munti.add(new Munte("Makalu", 8300)); + + System.out.println("Munti initial: " + munti); + Collections.sort(munti); + + System.out.println("Munti dupa sort: " + munti); + Collections.sort(munti, new ComparatorMunte()); + + System.out.println("Munti dupa sortare nume: " + munti); + } +} diff --git a/src/Sesion_15_CollectionsFramework/MapsExample.java b/src/Sesion_15_CollectionsFramework/MapsExample.java new file mode 100644 index 0000000..dccec13 --- /dev/null +++ b/src/Sesion_15_CollectionsFramework/MapsExample.java @@ -0,0 +1,50 @@ +package Sesion_15_CollectionsFramework; + +import java.util.HashMap; +import java.util.Map; +import java.util.TreeMap; + +public class MapsExample { + public static void main(String... args) { + Map hasMap = new HashMap<>(); + Map treeMap = new TreeMap<>(); + + hasMap.put("Romania", 20000000); + hasMap.put("Germania", 85000000); + hasMap.put("Franta", 6600600); + + + treeMap.put("Romania", 2000000); + treeMap.put("Germania", 8500000); + treeMap.put("Franta", 6600600); + + System.out.println("hasMap" + hasMap); + System.out.println("treemap" + treeMap); + + //print contains + System.out.println("Contains Romania: " + hasMap.containsKey("Romania")); + System.out.println("Contains 2000000" + treeMap.containsValue(2000000)); + + + for (String key : hasMap.keySet()) { + System.out.println("Key : " + key + " - value " + hasMap.get(key)); + } + +//+ var mapentri string intiger + for (Map.Entry entry : treeMap.entrySet()) { + System.out.println("Key: " + entry.getKey() + " - value " + entry.getValue()); + } +//update + hasMap.put("Romania", 1980000); + System.out.println(hasMap); + + TreeMap tree = new TreeMap<>(treeMap); + + System.out.println("Prima intrare: " + tree.firstEntry()); + System.out.println("Ultima intrare: " + tree.lastEntry()); + System.out.println("Intrare inferioara Germania: " + tree.lowerEntry("Germania")); + System.out.println("Intrare superioara Germania: " + tree.higherEntry("Germania")); + + + } +} diff --git a/src/Sesion_15_CollectionsFramework/Munte.java b/src/Sesion_15_CollectionsFramework/Munte.java new file mode 100644 index 0000000..fbb2903 --- /dev/null +++ b/src/Sesion_15_CollectionsFramework/Munte.java @@ -0,0 +1,31 @@ +package Sesion_15_CollectionsFramework; + +public class Munte implements Comparable { + private String nume; + private int inaltime; + + + public Munte(String n, int i) { + this.nume = n; + this.inaltime = i; + } + + public String getInaltime() { + return nume; + + } + + public String getNume() { + return getNume(); + } + + @Override + public int compareTo(Munte o) { + return Integer.compare(this.inaltime, o.inaltime); + } + + @Override + public String toString() { + return nume + " (" + inaltime + "m)"; + } +} diff --git a/src/Sesion_15_CollectionsFramework/SetExamples.java b/src/Sesion_15_CollectionsFramework/SetExamples.java new file mode 100644 index 0000000..db844a1 --- /dev/null +++ b/src/Sesion_15_CollectionsFramework/SetExamples.java @@ -0,0 +1,51 @@ +package Sesion_15_CollectionsFramework; + +import java.util.HashSet; +import java.util.Set; +import java.util.TreeSet; + +public class SetExamples { + public static void main(String[] args) { + Set hashSet = new HashSet<>(); + Set treeSet = new TreeSet<>(); + + addElement(hashSet, " Ion"); + addElement(hashSet, " Sam"); + addElement(hashSet, " Dan"); + addElement(hashSet, " Bob"); + addElement(hashSet, " Ion"); + + + //========================================= + + addElement(treeSet, " Ion"); + addElement(treeSet, " Sam"); + addElement(treeSet, " Dan"); + addElement(treeSet, " Bob"); + addElement(treeSet, " Ion"); + + + //display sets + System.out.println("HashSet: " + hashSet); + System.out.println("TreeSet: " + treeSet); + + String nume = "Ion"; + System.out.println("HashMap contains: " + nume + "?" + hashSet.contains(nume)); + System.out.println("Treset contains: " + nume + "?" + treeSet.contains(nume)); + + + boolean removed = hashSet.remove(nume); + System.out.println("Removeing: " + nume + " - " + (removed ? " success " : "not fund")); + + boolean removed1 = hashSet.remove(nume); + System.out.println("Removeing: " + nume + " - " + (removed1 ? " success " : " not fund")); + + } + + private static void addElement(Set set, String element) { + boolean added = set.add(element); + System.out.println(set.getClass().getSimpleName() + " : Adding" + element + " " + (added ? "Succes " : " Duplicate")); + } + + +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/Animal.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/Animal.java new file mode 100644 index 0000000..1815756 --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/Animal.java @@ -0,0 +1,5 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +public interface Animal { + void sound(); +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/Cat.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/Cat.java new file mode 100644 index 0000000..47c3eaa --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/Cat.java @@ -0,0 +1,13 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +public class Cat implements Animal { + @Override + public void sound() { + System.out.println("miau miau"); + } + + @Override + public String toString() { + return "pisica face miau miau"; + } +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/Dog.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/Dog.java new file mode 100644 index 0000000..e5b2b9f --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/Dog.java @@ -0,0 +1,13 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +public class Dog implements Animal { + @Override + public void sound() { + System.out.println("ham ham"); + } + + @Override + public String toString() { + return "Cainele face ham ham"; + } +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/IntegerPrinter.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/IntegerPrinter.java new file mode 100644 index 0000000..2846665 --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/IntegerPrinter.java @@ -0,0 +1,13 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +public class IntegerPrinter { + private int thingToPrint; + + public IntegerPrinter(int thingToPrint) { + this.thingToPrint = thingToPrint; + } + + public void print() { + System.out.println(thingToPrint); + } +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/Main.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/Main.java new file mode 100644 index 0000000..aaa0b5e --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/Main.java @@ -0,0 +1,82 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class Main { + public static void main(String... args) { +// equalsExamples(); + genericExamples(); + } + + public static void genericExamples() { + IntegerPrinter integerPrinter = new IntegerPrinter(5); + integerPrinter.print(); + + StringPrinter stringPrinter = new StringPrinter("bla bal"); + stringPrinter.print(); + +// Printer intPrinter = new Printer<>(52); +// Printer strPrinter = new Printer<>("ha ha"); +// intPrinter.print(); +// strPrinter.print(); + + Printer catPrinter = new Printer<>(new Cat()); + catPrinter.print(); + + Printer dogPrinter = new Printer<>(new Dog()); + dogPrinter.print(); + + + ArrayList catList = new ArrayList<>(); + catList.add(new Cat()); + +// Cat cat = catList.get(0); + + print(2, "hihi"); + + List intList = new ArrayList<>(); + intList.add(6); + +// printList(intList); + printListWhildcard(intList); + printListWhildcard(catList); + + printListWhildcard2(catList); + } + + //metoda generica cu 2 parametrii + public static void print(T p1, E p2) { + System.out.println("p1: " + p1 + " p2: " + p2); + } + + public static void printList(List list) { + System.out.println(list); + } + + public static void printListWhildcard(List list) { + System.out.println(list); + } + + public static void printListWhildcard2(List list) { + System.out.println(list); + } + + public static void equalsExamples() { + Persoana p1 = new Persoana("Ion", 30); + Persoana p2 = new Persoana("Ion", 30); + Persoana p3 = new Persoana("Maria", 25); + + System.out.println("p1 equals p2: " + p1.equals(p2)); + System.out.println("p1 equals p3: " + p1.equals(p3)); + + Set set = new HashSet<>(); + System.out.println("Adauga p1: " + set.add(p1)); + System.out.println("Adauga p2: " + set.add(p2)); + System.out.println("Adauga p3: " + set.add(p3)); + + System.out.println("Set size: " + set.size()); + } +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/Persoana.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/Persoana.java new file mode 100644 index 0000000..a9ebaa5 --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/Persoana.java @@ -0,0 +1,39 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +import java.util.Objects; + +public class Persoana { + private String nume; + private int age; + //ce se intampla daca am si o adresa de tip Adresa??? + + + public Persoana(String name, int age) { + this.nume = name; + this.age = age; + } + + @Override + public boolean equals(Object o) { + //Verificam daca parametrul metodei este null + if (o == null) { + return false; + } + //Verificam daca referintele sunt egale + if (o == this) { + return true; + } + //Verificam tipul obiectului sa fie persoana + if (!(o instanceof Persoana)) + return false; + //Facem un cast de la Object la Persoana + Persoana persoana = (Persoana) o; + + return persoana.age == this.age && Objects.equals(this.nume, persoana.nume); + } + + @Override + public int hashCode() { + return Objects.hash(nume, age); + } +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/Printer.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/Printer.java new file mode 100644 index 0000000..060ca98 --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/Printer.java @@ -0,0 +1,15 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + + +public class Printer { + private T thingToPrint; + + public Printer(T thingToPrint) { + this.thingToPrint = thingToPrint; + } + + public void print() { + thingToPrint.sound(); + System.out.println(thingToPrint); + } +} diff --git a/src/Sesion_16_Equals_HasCodeGenericsEnum/StringPrinter.java b/src/Sesion_16_Equals_HasCodeGenericsEnum/StringPrinter.java new file mode 100644 index 0000000..1d3856b --- /dev/null +++ b/src/Sesion_16_Equals_HasCodeGenericsEnum/StringPrinter.java @@ -0,0 +1,13 @@ +package Sesion_16_Equals_HasCodeGenericsEnum; + +public class StringPrinter { + private String thingToPrint; + + public StringPrinter(String thingToPrint) { + this.thingToPrint = thingToPrint; + } + + public void print() { + System.out.println(thingToPrint); + } +} diff --git a/src/Session_17_lambda/Animal.java b/src/Session_17_lambda/Animal.java new file mode 100644 index 0000000..a1031df --- /dev/null +++ b/src/Session_17_lambda/Animal.java @@ -0,0 +1,7 @@ +package Session_17_lambda; + +public class Animal { + public void makeSound() { + System.out.println("bla bla bla"); + } +} diff --git a/src/Session_17_lambda/AnonimousClassEx.java b/src/Session_17_lambda/AnonimousClassEx.java new file mode 100644 index 0000000..c1bba4d --- /dev/null +++ b/src/Session_17_lambda/AnonimousClassEx.java @@ -0,0 +1,21 @@ +package Session_17_lambda; + +public class AnonimousClassEx { + public static void main(String... args) { + Animal animal = new Animal(); + animal.makeSound(); + + + //clasa anonima, in cazul asta va fi o clasa fara nume dar va reprezenta un caine + Animal anonimAnimal = new Animal(){ + @Override + public void makeSound() { + System.out.println("ham ham"); + } + }; + + anonimAnimal.makeSound(); + + + } +} diff --git a/src/Session_17_lambda/AnonymousVsLambda.java b/src/Session_17_lambda/AnonymousVsLambda.java new file mode 100644 index 0000000..624a735 --- /dev/null +++ b/src/Session_17_lambda/AnonymousVsLambda.java @@ -0,0 +1,34 @@ +package Session_17_lambda; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +public class AnonymousVsLambda { + public static void main(String... args) { + List list = new ArrayList<>(); + list.add("a"); + list.add("d"); + list.add("b"); + list.add("c"); + + Collections.sort(list, new Comparator() { + @Override + public int compare(String o1, String o2) { + return o1.compareTo(o2); + } + }); + + System.out.println("Sorted list: " + list); + Collections.shuffle(list); + System.out.println("Shuffled list: " + list); + + Comparator com = (o1, o2) -> o1.compareTo(o2); + + Collections.sort(list, com); + + System.out.println("Sorted list: " + list); + + } +} diff --git a/src/Session_17_lambda/Calculator.java b/src/Session_17_lambda/Calculator.java new file mode 100644 index 0000000..9f9063a --- /dev/null +++ b/src/Session_17_lambda/Calculator.java @@ -0,0 +1,5 @@ +package Session_17_lambda; + +public interface Calculator { + double calculate(double a, double b, char operator); +} diff --git a/src/Session_17_lambda/LambdaExamples.java b/src/Session_17_lambda/LambdaExamples.java new file mode 100644 index 0000000..68475e3 --- /dev/null +++ b/src/Session_17_lambda/LambdaExamples.java @@ -0,0 +1,42 @@ +package Session_17_lambda; + +public class LambdaExamples { + public static void main(String... args) { + Printable printable = s -> { + System.out.println("salut"); + return "ciau" + s; + }; + + printThing(printable); +// printThing(() -> System.out.println("salut")); + + StringProcessor removeWhitespaces = str -> str.replace(" ", ""); + StringProcessor toUpperCase = str -> str.toUpperCase(); + + StringProcessor combined = removeWhitespaces.andThen(toUpperCase); + + System.out.println(combined.process("hello world")); + + + Calculator calculator = (a, b, operator) -> calcImpl(a,b,operator); + + System.out.println(calculator.calculate(3, 5, '+')); + } + + public static double calcImpl(double a, double b, char op){ + switch (op) { + case '+': + return a + b; + case '-': + return a - b; + case '*': + return a * b; + default: + return a / b; + } + } + + public static void printThing(Printable print) { + System.out.println(print.print("!")); + } +} diff --git a/src/Session_17_lambda/Printable.java b/src/Session_17_lambda/Printable.java new file mode 100644 index 0000000..d075fe6 --- /dev/null +++ b/src/Session_17_lambda/Printable.java @@ -0,0 +1,10 @@ +package Session_17_lambda; + +@FunctionalInterface +public interface Printable { + String print(String p1); + + default void faAltceva(){ + System.out.println("fa altceva!"); + } +} diff --git a/src/Session_17_lambda/StringProcessor.java b/src/Session_17_lambda/StringProcessor.java new file mode 100644 index 0000000..2d0e42f --- /dev/null +++ b/src/Session_17_lambda/StringProcessor.java @@ -0,0 +1,10 @@ +package Session_17_lambda; + +@FunctionalInterface +public interface StringProcessor { + String process(String str); + + default StringProcessor andThen(StringProcessor after) { + return input -> after.process(this.process(input)); + } +} diff --git a/src/Session_18_JavaStreams/Main.java b/src/Session_18_JavaStreams/Main.java new file mode 100644 index 0000000..d73f93e --- /dev/null +++ b/src/Session_18_JavaStreams/Main.java @@ -0,0 +1,7 @@ +package Session_18_JavaStreams; + +public class Main { + public static void main (String[] args){ + + } +} diff --git a/src/Session_18_JavaStreams/OptionalExamples.java b/src/Session_18_JavaStreams/OptionalExamples.java new file mode 100644 index 0000000..5c6922c --- /dev/null +++ b/src/Session_18_JavaStreams/OptionalExamples.java @@ -0,0 +1,43 @@ +package Session_18_JavaStreams; + +import java.util.Optional; + +public class OptionalExamples { + public static void main(String... args) { + Person person = getPersonByName("Ion"); + + if (person != null) + System.out.println("age: " + person.getAge()); + else + System.out.println("age: " + 0); + + + Optional optionalPerson = getOptionalPersonByName("Dana"); + if (optionalPerson.isPresent()) + System.out.println("age: " + optionalPerson.get().getAge()); + else + System.out.println("age: " + 0); + + + int age = optionalPerson.map(Person::getAge).orElse(0); + System.out.println("age: " + age); + + Person pers = optionalPerson.orElseGet(() -> new Person("UNKNOWN", 0)); + System.out.println("Pers age: " + pers.getAge()); + + //daca vrem exceptie cand nu este valoare do this +// optionalPerson.orElseThrow() + + + } + + public static Person getPersonByName(String name) { +// return new Person(name, 25); + return null; + } + + public static Optional getOptionalPersonByName(String name) { + return Optional.ofNullable(null); + } + +} \ No newline at end of file diff --git a/src/Session_18_JavaStreams/Person.java b/src/Session_18_JavaStreams/Person.java new file mode 100644 index 0000000..3505d3d --- /dev/null +++ b/src/Session_18_JavaStreams/Person.java @@ -0,0 +1,32 @@ +package Session_18_JavaStreams; + +import java.util.List; + +public class Person { + private String name; + private int age; + private List hobbies; + + + public Person(String name, int age) { + this.name = name; + this.age = age; + } + + public Person(String name, List hobbies) { + this.name = name; + this.hobbies = hobbies; + } + + public int getAge() { + return age; + } + + public String getName() { + return name; + } + + public List getHobbies() { + return hobbies; + } +} \ No newline at end of file diff --git a/src/Session_18_JavaStreams/StreamExamples.java b/src/Session_18_JavaStreams/StreamExamples.java new file mode 100644 index 0000000..4a2f758 --- /dev/null +++ b/src/Session_18_JavaStreams/StreamExamples.java @@ -0,0 +1,44 @@ +package Session_18_JavaStreams; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class StreamExamples { + public static void main(String... args) { + List strignList = Arrays.asList("a", "b", "c"); + Stream stringListStream = strignList.stream(); + + Map map = new HashMap<>(); + map.put("Ana", 25); + map.put("Ion", 30); + + Stream keyStream = map.keySet().stream(); + Stream valStream = map.values().stream(); + + //----------------------------------------------------------------------- + + int[] nr = {1, 2, 3, 4, 5}; + IntStream nrStream = Arrays.stream(nr); + + //------------------------------------------------------------------------- + + Stream customStream = Stream.of("a", "b", "c"); + + //------------------------------------------------------------------------- + + try (Stream lines = Files.lines(Path.of("example.txt"))) { + lines.forEach(System.out::println); + } catch (IOException ex) { + ex.printStackTrace(); + } + + + } +} \ No newline at end of file diff --git a/src/Session_18_JavaStreams/StreamImplExamples.java b/src/Session_18_JavaStreams/StreamImplExamples.java new file mode 100644 index 0000000..0d26e35 --- /dev/null +++ b/src/Session_18_JavaStreams/StreamImplExamples.java @@ -0,0 +1,68 @@ +package Session_18_JavaStreams; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class StreamImplExamples { + public static void main(String... args) { + filterOddNumbers(); + flatMapExample(); + concatenateListOfStrings(); + calculateAVG(); + } + + private static void calculateAVG() { + List numbers = Arrays.asList(10, 20, 30, 40); + + double avg = numbers.stream() + .mapToInt(Integer::intValue) + .average() + .orElse(0); + + System.out.println(avg); + } + + private static void concatenateListOfStrings() { + List words = Arrays.asList("apple", "banana", "orange"); + + String result = words.stream() + .collect(Collectors.joining(", ")); + + System.out.println(result); + } + + private static void flatMapExample() { + List people = Arrays.asList( + new Person("Bob", Arrays.asList("cititul", "mancatul")), + new Person("Ana", Arrays.asList("plimbare", "gaming")) + ); + + //Obtinem un stream cu liste de hobiuri + Stream> hobbyList = people.stream().map(Person::getHobbies); + // Apelam streamu-ul de liste si il concatenam intr-un stream de strings cu flatMap + Stream hobbies = hobbyList.flatMap(List::stream); + hobbies.forEach(System.out::println); + } + + public static void filterOddNumbers() { + List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + //before + + List oddNumbers = new ArrayList<>(); + for (Integer nr : numbers) { + if (nr % 2 == 0) + oddNumbers.add(nr); + } + + System.out.println("Odd numbers: " + oddNumbers); + + //@formatter:off + List streamOddList = numbers.stream() + .filter(n -> n % 2 == 0) + .toList(); + //@formatter:on + } +} \ No newline at end of file diff --git a/src/Studi/AgeValidation.java b/src/Studi/AgeValidation.java new file mode 100644 index 0000000..ce8a80d --- /dev/null +++ b/src/Studi/AgeValidation.java @@ -0,0 +1,48 @@ +package Studi; + +import java.util.Scanner; + +// Custom checked exception for invalid age +class InvalidAgeException extends Exception { + public InvalidAgeException(String message) { + super(message); + } +} + +public class AgeValidation { + + // Method to validate age + public static void validateAge(int age) throws InvalidAgeException { + if (age < 0 || age > 110) { + throw new InvalidAgeException("Age must be between 0 and 110."); + } + } + + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + + try { + // Prompt the user to enter their age + System.out.print("Enter your age: "); + int age = Integer.parseInt(scanner.nextLine()); + + // Validate the age + validateAge(age); + + // Display a success message if no exception is thrown + System.out.println("Age is valid."); + + } catch (InvalidAgeException e) { + // Handle the InvalidAgeException + System.out.println("Error: " + e.getMessage()); + } catch (NumberFormatException e) { + // Handle invalid number format + System.out.println("Invalid input. Please enter a valid number."); + } catch (Exception e) { + // Handle any other unexpected exceptions + System.out.println("An unexpected error occurred: " + e.getMessage()); + } + + scanner.close(); + } +} diff --git a/src/Studi/Calculator.java b/src/Studi/Calculator.java new file mode 100644 index 0000000..651dddc --- /dev/null +++ b/src/Studi/Calculator.java @@ -0,0 +1,60 @@ +package Studi; + +import java.util.Scanner; + +public class Calculator { + + // Method to perform the calculation + public static double calculate(double operand1, double operand2, char operator) { + switch (operator) { + case '+': + return operand1 + operand2; + case '-': + return operand1 - operand2; + case '*': + return operand1 * operand2; + case '/': + if (operand2 == 0) { + throw new ArithmeticException("Division by zero is not allowed."); + } + return operand1 / operand2; + default: + throw new IllegalArgumentException("Invalid operator: " + operator); + } + } + + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + + try { + // Prompt the user to enter the first number + System.out.print("Enter the first number: "); + double num1 = Double.parseDouble(scanner.nextLine()); + + // Prompt the user to enter the second number + System.out.print("Enter the second number: "); + double num2 = Double.parseDouble(scanner.nextLine()); + + // Prompt the user to enter the operator + System.out.print("Enter the operator (+, -, *, /): "); + char operator = scanner.nextLine().charAt(0); + + // Perform the calculation + double result = calculate(num1, num2, operator); + + // Display the result + System.out.println("The result is: " + result); + + } catch (NumberFormatException e) { + System.out.println("Invalid number format. Please enter valid numbers."); + } catch (ArithmeticException e) { + System.out.println("Error: " + e.getMessage()); + } catch (IllegalArgumentException e) { + System.out.println("Error: " + e.getMessage()); + } catch (Exception e) { + System.out.println("An unexpected error occurred: " + e.getMessage()); + } + + scanner.close(); + } +} diff --git a/src/Studi/FileCopyUtility.java b/src/Studi/FileCopyUtility.java new file mode 100644 index 0000000..9e9992d --- /dev/null +++ b/src/Studi/FileCopyUtility.java @@ -0,0 +1,52 @@ +package Studi; + +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.Scanner; +import java.io.FileNotFoundException; + +public class FileCopyUtility { + + // Method to copy the contents of the source file to the destination file + public static void copyFile(String sourcePath, String destinationPath) { + try (FileInputStream fis = new FileInputStream(sourcePath); + FileOutputStream fos = new FileOutputStream(destinationPath)) { + + byte[] buffer = new byte[1024]; + int bytesRead; + + // Read from source and write to destination + while ((bytesRead = fis.read(buffer)) != -1) { + fos.write(buffer, 0, bytesRead); + } + + } catch (FileNotFoundException e) { + System.out.println("Source file not found: " + e.getMessage()); + } catch (IOException e) { + System.out.println("Error occurred while copying the file: " + e.getMessage()); + } + } + + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + + try { + // Prompt the user to enter the source file path + System.out.print("Enter the source file path: "); + String sourcePath = scanner.nextLine(); + + // Prompt the user to enter the destination file path + System.out.print("Enter the destination file path: "); + String destinationPath = scanner.nextLine(); + + // Call the copyFile method + copyFile(sourcePath, destinationPath); + + } catch (Exception e) { + System.out.println("An unexpected error occurred: " + e.getMessage()); + } + + scanner.close(); + } +} diff --git a/src/TemeAbstraction/Main.java b/src/TemeAbstraction/Main.java index 2c2a973..be2a230 100644 --- a/src/TemeAbstraction/Main.java +++ b/src/TemeAbstraction/Main.java @@ -5,6 +5,8 @@ public static void runParentExample() { Parent obj1 = new FirstSubClass(); obj1.message(); + + Parent obj2 = new FirstSubClass(); obj2.message(); } diff --git a/src/sistem_gestiune_angajati/Employee.java b/src/sistem_gestiune_angajati/Employee.java index e9bd826..1dc093a 100644 --- a/src/sistem_gestiune_angajati/Employee.java +++ b/src/sistem_gestiune_angajati/Employee.java @@ -2,8 +2,8 @@ public abstract class Employee { - private String name; - private int id; + public String name; + public int id; private double salary; public Employee(String name, int id, double salary) {