|
|
|
|
class Circle()
{// le nom de mon objet commence par une majuscule
public double x, y; // Coordonnée du centre
private double r; // rayon du cercle
public Circle(double r) {
this.r = r;
}
public double area() {
return 3.14159 * r * r;
}
}
public class MonPremierProgramme() {
public static void main(String[] args) {
Circle c; // c est une référence sur un objet Circle, pas
un objet
c = new Circle(5.0); // c référence maintenant un objet alloué
en
mémoire
c.x = c.y = 10;
System.out.println("Aire de c :" + c.area());
}
}
try
{
Class c = String.class;
Object str = c.newInstance();
java.lang.reflect.Method m [] = c.getDeclaredMethods();
Method m = c.getDeclaredMethod("toString",null);
m.invoke(str,null);
for (int i=0 ; true ; i++)
{
System.out.println(m[i].toString());
}
}
catch(IndexOutOfBoundsException i)
{
//tout s'est bien déroulé
System.exit(0);
}
int [] array_of_int;
Color[][][] rgb_cube;
array_of_int = new int[42];
rgb_cube = new Color[256][256][256];
System.out.println(array_of_int[1] == 0); // affiche 'true'
System.out.println(rgb_cube[0][0][0] == null); // affiche 'true'
int[] primes = {1, 2, 3, 5, 7, 7+4};
int [] primes2 = new int[] {1, 2, 3, 5, 7, 7+4};
System.out.println(array_of_int.length); // affiche '42'
arrayOfInt[0] = 1;// Affecte la valeur 1 à la première case du tableau
arrayOfInt[42] = 1; // Lève une exception ArrayIndexOutOfBoundsException
class Circle
{
double x, y, r;
public Circle(double x1, double y1, double r1)
{
x = x1;
y = y1;
r = r1;
}
void move(x,y)
{
this.x = x;
this.y = y;
}
}
Circle c = new Circle(0,0,1);
public class Circle
{
...
void finalize()
{
System.out.println("Je suis garbage collecte");
}
}
...
Circle c1;
if (condition)
{
Circle c2 = new Circle(); // c2 référence une nouvelle instance
c1 = c2;
}
// La référence c2 n'est plus valide mais il reste une référence,c1,
// sur l'instance
c1=null; // L'instance ne possède plus de référence. Elle
n'est plus
// accessible. A tout moment le gc peut detruire l'objet.
Circle c = new Circle(0,0);
c.r = 3; // On accède à l'attribut r de l'objet référencé
par c
c.move(1,2); // On invoque la méthode move de l'objet référencé
par c
pi = Math.PI; // On accède a l'attribut statique de la classe Math
r = Math.sqrt(2); // On invoque la méthode statique de la classe Math
class Point
{
int x,y;
Point()
{
this(0,0);
}
Point(int x,int y)
{
this.x=x;
this.y=y;
}
}
class Circle
{
public static int num_circle = 0;
public static final double PI = 3.14159;
public double x, y, r;
public Circle(double r)
{
this.r = r;
num_circle++;
}
public Circle bigger(Circle c)
{
if (c.r > r)
{
return c;
}
else
{
return this;
}
}
public static Circle bigger(Circle c1, Circle c2)
{
if (c1.r > c2.r)
{
return c1;
}
else
{
return c2;
}
}
}
Circle c1 = new Circle(2.0);
Circle c2 = new Circle(3.0);
System.out.println("Nombre de cercle : " + Circle.num_circle);
Circle c3 = c1.bigger(c2); // c3 = c2
Circle c4 = Circle.bigger(c1, c2); // c4 = c2;
class Int
{
int val;
Int(int val)
{
this.val = val;
}
}
class C
{
void m(int i1, Int i2,Int i3)
{
i1++;
i2.val++;
i3=new Int(i3.val);
i3.val++;
}
void main(String []argv)
{
int a = 0;
Int b = new Int(0);
Int c = new Int(0);
m(a, b,c);
System.out.println("a="+a+",b="+b.val+",c="+c.val);
// a=0, b=1, c=0
}
}public class Circle
{
...
void finalize()
{
System.out.println("je suis garbage collecte");
...
}
}
...
Circle c1;
if (condition)
{
Circle c2 = new Circle(); // c2 référence une nouvelle instance
de la classe Circle
c1 = c2; // c1 référence le même objet que c2
}
// La référence c2 n'est plus utilisée par la suite donc
elle peut être détruite à tout moment. En revenche, il reste
une référence (c1) sur l'instance
c1 = null; // L'instance ne possède plus aucune référence.
Elle n'est plus accessible.
// A tout moment, le ramasse miette peut détruire l'objet
class
C
{
static Vector v1 = new Vector();
static
{
v1.addElement(new Integer(1));
}
Vector v2 = new Vector();
static
{
v2.addElement(new Integer(1));
} // executé par chaque constructeur après super
}
class Ellipse
{
public double r1, r2;
public Ellipse(double r1, double r2)
{
this.r1 = r1; this.r2 = r2;
}
public double area()
{
...
}
}
final class Circle extends Ellipse
{
public Circle(double r)
{
super(r, r);
}
public final double getRadius()
{
return r1;
}
}
Ellipse e = new Ellipse(2.0, 4.0);
Circle c = new Circle(2.0);
System.out.println("aire de e: " + e.area() + ", aire de c :"
+ c.area());
System.out.println((e instanceof Circle)); // false
System.out.println((e instanceof Ellipse); // true
System.out.println((c instanceof Circle)); // true
System.out.println((c instanceof Ellipse)); // true (car Circle dérive
de
Ellipse)
e = c; // e reference l'instance c en
tant qu'ellipse
System.out.println((e instanceof Ellipse)); // true
System.out.println((e instanceof Circle)); // true
double r = e.getRadius(); // error: Method getRadius() not found in class Ellipse
c = e; // error: Incompatible type for =. Explicit cast needed.
class A
{
int x;
}
class B extends A
{
Object x;
void m()
{
}
Object m1()
{
return new Object();
}
void m2()
{
}
protected void m3()
{
}
void m4() throws Exception
{
}
}
class C extends B
{
int x;
void m() {}
int [] m1()
{
return new int[1];
} // Erreur car type de retour différents
void m2() throws IOException
{} // Erreur car m2 ne lève pas d'exception
void m3()
{}// Erreur car visibilité plus restreinte que protected
protected void m4() throws IOException {} // Ok car IOException
sous-type de Exception
void main(String [] argv)
{
x; // attribut x de la classe C
this.x; // idem
super.x; // attribut x de la classe B
super.super.x; // erreur
((B)this).x; // attribut x de la classe B
((A)this).x; // attribut x de la classe A
m(); // Référence la méthode m de la classe de
//this qui ne sera connu que dynamiquement
super.m() // Référence la methode m de la classe B
super.super.m(); // erreur
((B)this).m(); // Référence la méthode m de la classe de
//this (et non de la classe B)
}
}
public class A
{
void m(A a)
{
System.out.println("A");
}
}
public class B extends A
{
void m(B b)
{
System.out.println("B");
}
public static void main(String args[])
{
B b1 = new B();
A b2 = new B();
b1.m(b2);
}
}
public class C extends B
{
void m(A a)
{
System.out.println("C");
}
public static void main(String args[])
{
B c1 = new C();
A c2 = new C();
c1.m(c2);
}
}
private void writeObject(ObjectInputStream s)
throws IOException
{
s.defaultWriteObject();
}
private void readObject(ObjectOutputStream s)
throws IOException
{
s.defaultReadObject();
}
 |
|
|
|
© 2001 IsepFAQtory Tous droits réservés
|