Mensajes

bruto no es el que pregunta

burto es el que quiere embrutecer a gente inocente


Formulario implements ChangeListener{
....
addChangeListener(this);
....
}

el objeto es al mismo tiempo de tipo Formulario y de tipo ChangeListener


al momento de compilar el compilador procesa el codigo fuente y pasa por un montón  de face de verificación y optimizacion (class loading) luego llena sus areas de memoria y luego entrega el control a el excution engine

la verificación se hace al momento de compilar en caso de pasar crear los ficheros .class y en caso de fallar el compilador te saca la lengua y te hace acordar lo mal que lo has echo y en que linea o lineas exacta y por que motivo o motivos fracasaste

el compilador es el que te dice si esta bien tu codigo fuente o si tu fuente vale lo mismo que las promesas de tu ex

reflexion solo funciona cuando el programa esta corriendo no al momento de compilar

yo tengo paciencia para los que quieran mejorar

mas bien soy muy mala leche para los que se esfuerzan en ser lo mas brutos posible y luego tratan de hacer todo lo posible en embrutecer  al resto

recien estoy estudiando y mejorando mi habilidad en IA cuando tenga algo hare tutorial bueno y si les es importante usar opencv lo hare con eso

ahora estoy trabajando en el algebrea booleana para luego hacer condicionales
luego hare funciones y talves termine en bucles

bueno este desarrollo es incremental y tendre un tiempo de refactoring para mejorar el rendimiento la testeabilidad y facilidad de lectura

ya he escrito codigo mas complicado y con mas limpieza

***** que p**a he hecho con mi vida he puesta a la programación en un pedestal le dedique mucho de mi no se si esta bien o esta mal no se que mas sentir

la sarna con gusto no pica

estoy estudiando AI

quieren que les enseñe como se usa inteligencia artificial para hacer cosas aterradoras
saltar captchas, controlar los clasificadores de imagen ( que reconoscan mal el rostro ) una aplicacion con un solo botonazo y devuelva shell para los que tienen el dedo gordo como yo

hagan su pedido

que malito eres

bueno yo en mis malos tiempos(mejores momentos de mi vida) solia ver el código fuente de la pagina buscar el archivo style.css ojala que las cosas no hayan cambiado

otra manera es ver los archivos javascript tienes que leerlo luego buscas en el control de versiones de wordpress que el archivo sea exactamente igual

hola para todos aquellos que se preguntan como crear su propio evaluador de expresiones del tipo 5*4 +3 -2 *(5) a qui les tengo un pequeño ejemplito en menos de 81 lineas y sin usar regex

Código (java) [Seleccionar] Expandir

package javaapplication17;

import java.util.HashMap;

public class Interpreter {

    private final HashMap<String, String> variables = new HashMap<>();

    public static void main(String[] args) {
         Interpreter interpreter = new Interpreter();
        //calculation
        for (String text : new String[]{
            "1",
            "12",
            "5^2",
            "12+13",
            "4+2-1",
            "(1)",
            "(4/2+1*2)",
            "(1+3)+(5+6-3+13)",
            "3*(4+2)",
            "3*4*(5+3)+16+2",
            "8*7+(4+3+6*(5+4))",}) {

            System.out.println("text= " + text + " " + interpreter.evalProgram(text));
        }
        //programing feature booleans
        System.out.println();
        System.out.println("booleans");
        System.out.println();
        for (String text : new String[]{
            "1<2",
            "2>3",
            "12>13",
            "12<14",
            "(5+1)<14",
            "14<(5+1)",
            "(1+2)-3<4*2",
            "true",
            "false",
            "false&true",
            "false&true",
            "false&true|true",
            "true&false|true",
            "1+2<3&4<2|false",
            "(1+2)*3-1<4|false&true|(3+1)<4"}) {
            Interpreter programEvaluetor = new Interpreter();
            final String evalBoolean = programEvaluetor.evalProgram(text);
            System.out.println(text + " = " + evalBoolean);
        }
        //simple scripts

        System.out.println();
        System.out.println("programs");
        System.out.println();
        for (String text : new String[]{
            "1",
            "3+2-1",
            "3+2-1\n1+2+1",
            "4*5\n5*3",
            "5*8\n4+2\n5+5+5",
            "a=3*4\na",
            "b=3*4\nb",
            "abc=3*4\nabc\ncde=2*5+1\ncde",
            "a=2\nb=3\nc=a+b\nc",
            "c=true\nc",}) {
            Interpreter programEvaluetor = new Interpreter();
            System.out.println("=======program================================");
            System.out.println(text);
            System.out.println("=======endprogram=============================");
            System.out.println("=======output program=========================");
            System.out.println(programEvaluetor.evalProgram(text));
            System.out.println("=======end output program=====================");
            System.out.println("");
            System.out.println("");
        }

        //conditionals programs
        System.out.println();
        System.out.println("conditionals programs");
        System.out.println();
        for (String text : new String[]{
            "1\nif(true){\n2\n}",
            "if(false){\n1\n}",
            "2\nif(true){\n1\n}",
            "2\nif(false){\n1\n}\n3",
            "1\nif(true){\n2\n}\n3",}) {
            Interpreter programEvaluetor = new Interpreter();
            System.out.println("=======program================================");
            System.out.println(text);
            System.out.println("=======endprogram=============================");
            System.out.println("=======output program=========================");
            System.out.println(programEvaluetor.evalProgram(text));
            System.out.println("=======end output program=====================");
            System.out.println("");
            System.out.println("");
        }
        //conditionals programs
    }

    private boolean evalCondition(String condition) {
        final String evalBoleanExpresion = evalBoleanExpresion(condition.substring(3, condition.length() - 2));
        return Boolean.parseBoolean(evalBoleanExpresion);
    }

    private String evalProgram(final String expresion) {
        String[] comands = expresion.split("\n");
        String result = "";
        boolean run = true;
        for (int i = 0; i < comands.length; i++) {
            String comand = comands[i];
            if (comand.startsWith("if")) {
                run = evalCondition(comand);
                continue;
            }

            if (comand.startsWith("}")) {
                run = true;
                continue;
            }

            if (run) {
                final String evalComand = evalComand(comand);
                if (!evalComand.isEmpty()) {
                    result += evalComand + "\n";
                }
            }

        }

        return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
    }

    private String evalComand(String expresion) {
        String[] comandPart = expresion.split("=");
        String result = "";

        if (comandPart.length == 1) {
            String candidate = comandPart[0];
            if (candidate.equals("true") || candidate.equals("false")) {
                return eval(expresion);
            }
            if (candidate.chars().allMatch(Character::isLetter)) {
                return "" + variables.get(candidate);
            }
            return eval(expresion);
        }
        if (comandPart.length == 2) {
            variables.put(comandPart[0], (eval(comandPart[1])));

            return "";
        }

        return result;
    }

    private String eval(String inputString) {

        String buffer = "";
        int beginIndex = -1;

        for (int i = 0; i < inputString.length(); i++) {
            final char character = inputString.charAt(i);
            if (character == '(') {
                beginIndex = i;
                buffer = "";
                buffer += character;
            }
            if (!buffer.isEmpty()) {
                String charLetter = (character + "");
                buffer += charLetter.equals("(") || charLetter.equals(")") ? "" : charLetter;
            }
            if (character == ')') {

                buffer += character;
                inputString = inputString.substring(0, beginIndex) + evalParentesis(buffer) + inputString.substring(beginIndex + buffer.length());
                i = 0;
                buffer = "";

            }
        }

        return "" + evalExpresion(inputString);
    }

    private String evalParentesis(String coeficientString) {

        return evalExpresion(coeficientString.substring(1, coeficientString.length() - 1));
    }

    private String evalExpresion(String expresion) {
        String result = "";
        if (expresion.contains("<")
                || expresion.contains(">")
                || expresion.contains("&")
                || expresion.contains("|")
                || expresion.contains("true")
                || expresion.contains("false")) {
            result = evalBoleanExpresion(expresion);
        } else {
            result = evalAddExpresion(expresion) + "";
        }

        return result;
    }

    private int evalAddExpresion(String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        int result = 0;
        for (int i = 0; i < expresion.length(); i++) {
            char character = expresion.charAt(i);
            buffer += character;
            if (i == characters.length - 1
                    || characters[i + 1] == '+'
                    || characters[i + 1] == '-') {

                if (buffer.startsWith("-")) {
                    result -= evalSub(buffer.replace("-", ""));
                } else {
                    result += evalSub(buffer.replace("+", ""));
                }
                buffer = "";
            }

        }

        return result;
    }

    private int evalSub(final String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        int result = 1;
        for (int i = 0; i < expresion.length(); i++) {
            char character = expresion.charAt(i);
            buffer += character;
            if (i == characters.length - 1
                    || characters[i + 1] == '*'
                    || characters[i + 1] == '/') {

                if (buffer.startsWith("/")) {
                    result /= evalExpo(buffer.replace("/", ""));
                } else {
                    result *= evalExpo(buffer.replace("*", ""));
                }
                buffer = "";
            }

        }

        return result;
    }

    private int evalExpo(final String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        int result = 1;
        for (int i = expresion.length() - 1; i >= 0; i--) {
            char character = expresion.charAt(i);
            buffer = character + buffer;
            if (i == 0 || characters[i - 1] == '^') {
                result = (int) (Math.pow(Integer.parseInt(evalElement(buffer.replace("^", ""))), (result)));
                buffer = "";
            }

        }
        return result;
    }

    private String evalElement(String expresion) {

        if (expresion.chars().allMatch(Character::isLetter)) {
            return variables.get(expresion);
        } else {
            return expresion;
        }

    }

    private String evalBoleanExpresion(String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        boolean result = true;
        for (int i = 0; i < expresion.length(); i++) {
            char character = expresion.charAt(i);
            buffer += character;
            if (i == characters.length - 1
                    || characters[i + 1] == '&'
                    || characters[i + 1] == '|') {

                if (buffer.startsWith("&")) {
                    result &= Boolean.parseBoolean(evalBooleanElement(buffer.replace("&", "")));
                } else if (buffer.startsWith("|")) {
                    result |= Boolean.parseBoolean(evalBooleanElement(buffer.replace("|", "")));
                } else {
                    result = Boolean.parseBoolean(evalBooleanElement(buffer));
                }
                buffer = "";
            }

        }

        return result + "";
    }

    private String evalBooleanElement(final String expresion) {
        String result = "";
        if (expresion.contains("<") || expresion.contains(">")) {

            String[] split = expresion.split("<|>");
            String left = evalExpresion(split[0]);
            String right = evalExpresion(split[1]);

            if (expresion.contains("<")) {
                result = "" + (Integer.parseInt(left) < Integer.parseInt(right));

            }
            if (expresion.contains(">")) {
                result = "" + (Integer.parseInt(left) > Integer.parseInt(right));
            }
        } else {
            result = expresion;
        }

        return result;
    }
}




en un futuro agregare la funcionalidad de de agregar variables funciones bucles y condicionales para que se paresca a javascript  

porfavor cuentenme lo que quieran del post preguntas traumas amensas o respuesta troll pero no me ignoren por que soy una perra de atención


diganme si lo han usado y en que

1 para que el compilador te oblige a que escribas el cuerpo de metodo a implementar
2 por que cuando escribieron el metodo addChangeListener lo hicieron asi

addChangeListener(ChangeListener l){
....
}


dale una repasada a lo que son las clases e interfaces y como se usan y tambien a los inner clases

eclipse no tiene nada que ver

tienes que pasarle un objeto por que asi funciona el patron de diseño observador

y se le pasa un objeto entero debido a que java en las versiones anterirores a la 8 a los metodos solo puedes pasarle objetos no hay forma de pasar como parametros a metodos

cuando el usuario le hace click al radiobutton

waaa no lei bien

le quitas el parrallel(linea 3) y ya  se ejecuta en un solo nucleo
o programas normal con bucles y sin usar hilos y ya no habría forma de usar varios nucleos