java1

java
Java compilation et interpretation:
Java est un langage interprété, ce qui signifie qu’un programme compilé n’est pas directement
exécutable par le système d’exploitation mais il doit être interprété par un autre programme,
qu’on appelle interpréteur. La figure . illustre ce fonctionnement.

Un programmeur Java écrit son code source, sous la forme de classes, dans des fichiers dont
l’extension est .java. Ce code source est alors compilé par le compilateur #javac en un langage
appelé #bytecode et enregistre le résultat dans un fichier dont l’extension est .class. Le
bytecode ainsi obtenu n’est pas directement utilisable. Il doit être interprété par la machine
virtuelle de Java qui transforme alors le code compilé en code machine compréhensible par le
système d’exploitation. C’est la raison pour laquelle Java est un langage portable : le bytecode
reste le même quelque soit l’environnement d’exécution.
PACKAGES:
Toutes ces classes sont organisées en packages (ou bibliothèques) dédiés à un thème précis.
Parmi les packages les plus utilisés, on peut citer les suivants :

Pour accéder à une classe d’un package donné, il faut préalablement importer cette classe ou
son package. Par exemple, la classe Date appartenant au package java.util qui implémente un
ensemble de méthodes de traitement sur une date peut être importée de deux manières :

une seule classe du package est importée :

import java.util.Date ;

toutes les classes du package sont importées (même les classes non utilisées) :

import java.util.* ;

Le programme suivant utilise cette classe pour afficher la date actuelle :

import java.util.Date ;
public class DateMain { public static void main(String[] args)
{ Date today = new Date();
System.out.println(”Nous sommes le ” + today.toString());
}
}

Il est possible de créer vos propres packages en précisant, avant la déclaration d’une classe,
le package auquel elle appartient. Pour assigner la classe précédente à un package, nommé
fr.emse, il faut modifier le fichier de cette classe comme suit :

package fr.emse ; import java.util.Date ; public class DateMain { ... }

1

package firstP;

public class main {

public static void main(String[] args) {

// TODO Auto-generated method stub
System.out.println("nouhayla");

public static void main(string[] args)

public static void main(String[] args) {

System.out.println("Hello World");

sysout+ctr+space
}

to import the scanner

import java.util.Scanner;
package firstt;

import java.util.Scanner; //Import the Scanner class

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);//Create a Scanner object

System.out.println("enter your name");
String fuckJava = scanner.nextLine();
System.out.println("i said"+fuckJava);
int age = scanner.nextInt();
System.out.println("i'am " +age);

GUI
```
package firstt;
import javax.swing.JOptionPane;

public class Main{

public static void main(String[] args) {

String name = JOptionPane.showInputDialog("name a teacher");

JOptionPane.showMessageDialog(null,"Fuck you "+name);

int number = Integer.parseInt(JOptionPane.showInputDialog("how many men

did you fuck")); //to convert from string to integer
JOptionPane.showMessageDialog(null,"i fucked "+number);

}
}

lorseque on declare un constructeur surcharge il distruit le constructeur par default.

un attribut objet / tableau objet = passage par refernce.

pour les types simples (char - int - float ...) = passage par valeur.

compare : (compire)
retourne un entier compare un attribut par un attribut

int p = object.compare(onotherobject);//passage par reference

equals :
The equals() method compares two strings, and returns true if the strings are equal, and false
if not.

boolean q = s1.equals(s2));

In simple words, == checks if both objects point to the same memory location whereas
. equals() evaluates to the comparison of values in the objects.

equalqIgnoreCase() <= to ignore the lower case difference

this :
pointe sure l'object lui meme, lorsque on utilise une variable globale et une variable local dans
une classe
je vais preceder celle qui est globale par this pour differentier entre la variable globale et local

==> this.varibale_globale

-- il faut jamais affecter une nouvelle valeur a this

pourquoi == car c'est equivalent d'affecter une valeur a une refernce car this c'est un pointeur ,
qui retourne l"adresse de l'objet lui meme

The #get method returns the variable value, and the #set method sets the value.

getclass:
Return Value: This method returns the Class details which is the parent Class of the Writer
instance.

maVoiture.getclass(); // retoune un objet de type class

class classVoiture = maVoiture.getclass(); // class est une class, vrai

instance of :
sert a doneer un bool disant que c'est objet est une instance de cette class

a boool operator that checks if an object is an instance of a specific class

String:
longeur :

machaine.length() ; // avec les parametres car c'est ume methode

comapraison :

machaine.equal("fuck you") ; //
concatenation :

String essai = "fuck" + "you" ;

String essai = "fuck".concact("you") ;

jamais comaprer un string avec un double egal == car ca donnera toujours false*

substring:
t = "c'est le moment";
String sub = t.substring(3,5) ; // sub = est // extraction d'un sous-chaine

charAt:
t = "c'est le moment";
char sub = t.charAt(2) ; // " " extraction d'un caractere
boolean b1;
b1 = t.equals("hello") ; // false

compareTo:
int r; r = t.compareTo("bonjour") ;

Returns:

An int value: 0 if the string is equal to the other string.

< 0 if the string is lexicographically less than the other string

0 if the string is lexicographically greater than the other string (more characters)

indexOf:
r = t.indexOf ('t') ;

je donne un char et il va me retourner son indice .

lastIndexOf:
int r; r = t.compareTo("bonjour") ; //commance mn la fin de la chaine

replace :
string nouv = t.replace('a','h'); // remplacemenr sans modification de la chaine initiale

Static : (variable de class)

c'est une variable qui change pas de valeur pour tout les objects creer dans cette
classe

j'accede a sa valeur via la classe

il y'a une seule copie de cette static variable pour toute la classe(pour tous les objets )
( amelioration dyla hiya l variable globale)
2. can not be initialized using constructors
3. katwld u tmut m3a lmut u lwlada dyl l programme
4. a static variable inside a class should be initialized explicitly by the
user

static variables and methods belong to the class , they are shared between all objects.
we can acces the static variable and methods ima b l class or the object.

static int nouhayla;

static int getNouhayla(){ // we are able to acces the nouhayla variable inside
this method because it is a static variable
return nouhayla;

static int numberOfCircles;

circle(){
numberOfCircles++;
}

CONSTANTES :
ellles sont toujours ecrits en majiscule.
elles sont defines en plus avec le mot-cle final
public class Galerie{

public static final int MASS_MAX = 150;

}

// pour y acceder, il faut non pas identificantion d'objet mais le nom de la classe

if (maVoiture.getWeightLimite() <= Galerie.MAX_MASS)

instance :
represenation physique d'une classe

Arrays:
1D:

String car[] = {"camero" , "camera" , "caca"} ;

String car[] = new String[3];

2D:

String[][] cars = new String[3][3] ;

Heritage:
In Java, it is possible to inherit attributes and methods from one class to another. We group the
"inheritance concept" into two categories:

subclass (child) - the class that inherits from another class

superclass (parent) - the class being inherited from

To inherit from a class, use the extends keyword.

class Vehicle {
protected String brand = "Ford"; // Vehicle attribute
public void honk() { // Vehicle method
System.out.println("Tuut, tuut!");
}
}

class Car extends Vehicle {

 private String modelName = "Mustang"; // Car attribute
public static void main(String[] args) {

// Create a myCar object

Car myCar = new Car();

// Call the honk() method (from the Vehicle class) on the myCar object
myCar.honk();

// Display the value of the brand attribute (from the Vehicle class) and the value of
the modelName from the Car class
System.out.println(myCar.brand + " " + myCar.modelName);
}
}

Polymorphisme:
Polymorphism means "many forms", and it occurs when we have many classes that are related
to each other by inheritance.

Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods
from another class. Polymorphism uses those methods to perform different tasks. This allows
us to perform a single action in different ways.

class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}

class Pig extends Animal {

public void animalSound() {
System.out.println("The pig says: wee wee"); // we modified the inherited method
animalSound
}
}

class Dog extends Animal {

public void animalSound() {
System.out.println("The dog says: bow wow");
}
}

Abstract:
 absatract method is a method that doesn't conatin a body
abstract class : you can't create object form an abstract class but you can make
subclasses of it
we can create a cincrete not abstract methods in an abstratc classs
the abstract key is #abstract :

Public abstract class zaboun {}

Intreface :
every intreface has abstract methods by default .

you can implement as much as interfaces u want in java ( unlike an abstract class ( u can
extend one class))
every field decared in an interface it is final and static