import java.lang.Thread;



/**
 *
 * @author hpmini
 */
public class Threads extends Thread{
public static boolean running = true;
 public void run(){
     while(running){

System.out.println("Saludos");

  

 }}
 public static void shtdwn(){
 running = false;}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
 Threads Threads1 = new Threads();
        Threads1.start();
        stopIt stop = new stopIt();
        stop.start();
    }
}
 class stopIt extends Thread{
 public void run(){  try{
    Thread.sleep(1000);
    Threads.shtdwn();
    
} catch (InterrumpedException iox){}
    }
 public boolean running = false;
}
    

public class algoxD {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
System.out.println(ma(23,77,77)); 
	}
	//dos generis dan problem
	  static <T extends Comparable<T>> T ma (T a ,T b, T c){  // EXPLIKAD ESTO PORVAVOR
			T m = a;  
		if (b.compareTo(a)>0)
		  m = b;
		if (c.compareTo(m)>0)
		  m = c;
		  return m;
	  
	  }
}

 public class List<T>
{ // que significa <List> 
	const int defaultCapacity = 4;

	T[] items;// ahora otra t pero es un array¿?
	int count;

	public List(): this(defaultCapacity) {}
	public List(int capacity) {
		items = new T[capacity];
	}

	public int Count {
		get { return count; }
	}
	public int Capacity { //Esto parexe un método con accesors
		get {
			return items.Length;
		}
	
	set {
			if (value < count) value = count;
			
if (value != items.Length) {
				T[] newItems = new T[value]; //explicad este uso de las T[]
				Array.Copy(items, 0, newItems, 0, count);
				items = newItems;
			}
		
}
	}

	public T this[int index] {
		get {
			return items[index];
		}
		set {
			items[index] = value;
			OnChanged();
		}
	}

	public void Add(T item) {//¿T item?
		if (count == Capacity) Capacity = count * 2;
		items[count] = item;
		count++;
		OnChanged();
	}
	protected virtual void OnChanged() {
		if (Changed != null) Changed(this, EventArgs.Empty);
	} \\De donde ha salido Changed que es yo no lo he visto ,lo juro , Y ,¿esto es un método?

	public override bool Equals(object other) {
		return Equals(this, other as List<T>);//Esto que es y porque usa list<>
	}

	static bool Equals(List<T> a, List<T> b)
 {
		
if (a == null) return b == null;
		
if (b == null || a.count != b.count) return false;
		
for (int i = 0; i < a.count; i++) {

			if (!object.Equals(a.items[i], b.items[i])) {
				return false;
			}
		}
 
     return true;
	}


	public static bool operator ==(List<T> a, List<T> b) {//que hace y queesesto¿?
		return Equals(a, b);
	}
	public static bool operator !=(List<T> a, List<T> b) {
		return !Equals(a, b);
	}

}