Clever Geek Handbook

Programação estrutural versus OOP

Dia bom. Neste artigo, quero mostrar não o que é melhor estruturado ou programação de objetos, mas como escrever ali e ali. E talvez isso sirva de escolha para quem quer apenas começar a programar e não sabe qual linguagem escolher e o que poderia ser mais conveniente. Tomei C e JAVA como exemplo.



Vou começar com a primeira coisa que vem à mente. Parece não ser um padrão, mas às vezes você tem que usá-lo em OOP. Primeiro, escrevo um exemplo em java. Digamos que precisamos criar uma classe para dois tipos de implementação. Por exemplo, precisamos criar uma classe para conectar ao site via http e https. Este é um pequeno exemplo, por exemplo, o mesmo método pode ser usado quando você deseja desenhar para android em Opengl 2.0 es e Opengl 3.0 es. Nesse caso, haverá mais código e, se você fizer da maneira que irei dar, o código parecerá normal. Mas esse método, é claro, não foi inventado por mim, eu mesmo li no livro algum dia. E então https e http. Para fazer isso, você precisa criar uma interface. E atribua a classe necessária a esta interface, dependendo do tipo de protocolo. Não me lembro exatamente, mas parece que li em algum lugar que OOP define o cérebro.Isso permite que você escreva um código bonito e competente. Talvez por isso. Mas quase não programo em OOP, e é por isso que talvez eu escreva tanto código, e um programador de verdade fará um código mais conciso. Mas eu quero te mostrar um exemplo. Esta é a interface java. 



import java.net.*;
import java.io.*;

interface IProtocol {
	public void connect ( URL url );
	public URLConnection getConnection ( ) throws IOException;
}


Aqui estamos declarando duas funções, uma para conectar e outra para obter URLConnection. Agora existem duas classes para que isso funcione. 



import java.net.*;
import java.io.*;

public class Http implements IProtocol {
	public URL url;

	public void connect ( URL url ) {
		this.url = url;
	}

	public HttpURLConnection getConnection ( ) throws IOException {
		return ( HttpURLConnection ) url.openConnection( );
	}
}



import java.net.*;
import javax.net.ssl.*;
import java.io.*;

public class Https implements IProtocol {
	public URL url;

	public void connect ( URL url ) {
		this.url = url;
	}

	public HttpsURLConnection getConnection ( ) throws IOException {
		return ( HttpsURLConnection ) url.openConnection ( );
	}
}


A quantidade de código que você precisa escrever em connect e getConnection não é importante. Por exemplo, escolhi um pequeno código, mas pode ser muito, se por exemplo Opengl es to program. Mas é conveniente. Portanto, a função principal permanece. 



import java.net.*;
import java.io.*;

public class Main {
	public static void main ( String[] args ) {
		URL url = null;
		try {
			url = new URL ( "https://www.google.com" );
		} catch ( MalformedURLException e ) {
			return;
		}

		String protocol = url.getProtocol ( );

		IProtocol prot = null;

		switch ( protocol ) {
			case "http": prot = new Http ( ); break;
			case "https": prot = new Https ( ); break;
			default: return;
		}

		prot.connect ( url );

		URLConnection conn = null;
		try {
			conn = prot.getConnection ( );
		} catch ( IOException e ) {
			return;
		}

		conn.setDoOutput ( true );

	}
}


Você pode usar curl em C e não escrever muito código, mas como esse exemplo poderia ser resolvido usando C? C tem indicadores - esse é o seu poder. E aqui está um exemplo em C - a função principal.



arquivo main.c 

#include <stdio.h>
#include "conn.h"

struct conn conn;

#define HTTP_PROTOCOL       1
#define HTTPS_PROTOCOL      2
#define ERROR_PROTOCOL     -1

static int get_protocol ( void ) {
	return HTTP_PROTOCOL;
}

int main ( int argc, char **argv ) {

	switch ( get_protocol ( ) ) {
		case HTTP_PROTOCOL: init_http ( &conn ); break;
		case HTTPS_PROTOCOL: init_https ( &conn ); break;
		case ERROR_PROTOCOL: return -1;
	}

	conn.connect ( "www.google.com" );
	char *data = conn.read ( );
}


A estrutura conn é declarada em outro arquivo.



arquivo conn.h 

#ifndef __CONN__
#define __CONN__
struct conn {
	void ( *connect ) ( const char *url );
	char *( *read ) ( void );
};

void init_http ( struct conn *conn );
void init_https ( struct conn *conn );
#endif


Existe todo um arquivo com escopo alocado para init_http, que é necessário para http.



arquivo http.c 

#include "conn.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>

static int sockfd;

static void connect_http ( const char *url ) {
	sockfd = socket ( AF_INET, SOCK_STREAM, 0 );
}

static char *read_http ( void ) {
	return NULL;
}

void init_http ( struct conn *conn ) {
	conn->connect = connect_http;
	conn->read = read_http;
}


Ssl é adicionalmente necessário para init_https. Portanto, este arquivo conterá todos os dados necessários para esta conexão.



arquivo https.c 

#include "conn.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <openssl/ssl.h>
#include <stdio.h>

static int sockfd;
static SSL *ssl;

static void connect_https ( const char *url ) {
	sockfd = socket ( AF_INET, SOCK_STREAM, 0 );
}

static char *read_https ( void ) {
	return NULL;
}

void init_https ( struct conn *conn ) {
	conn->connect = connect_https;
	conn->read = read_https;
}


Se você gostar do artigo, escreverei uma sequência no futuro. Embora eu provavelmente ainda não conheça o OOP bem o suficiente para escrever mais exemplos, acho que se eu não desistir do OOP, os leitores iniciantes ficarão interessados ​​em ver as diferenças ao escrever em programação estruturada e OOP.


More articles:


All Articles