View Full Version : [Java]Problema Ereditarietà!!....ho bisogno del vostro aiuto!
Ciao a tutti! :)
Per la realizzazione di un progetto universitario necessito della realizzazione di una classe java che possa avere dei metodi risiedenti su un'altra classe.
Poichè le variabili istanza della classe 'Principale' sono privati, la classe 'Secondaria' dovrà avervi accesso usando dei metodi propri della classe 'Principale'.
Tutto questo serve per la realizzazione di un calcolatore binario che deve dare l'opportunità all'utente finale di aggiungere delle operazioni specifiche.
publi class Calc{
public calc(){
var 1 = 1;
var 2 = 2;
risultato = 0;
}
public int Get_Var1(){
return var1;
}
public void Set_Var1(int x){
var1 = x;
}
public int Get_Var2(){
return var2;
}
public void Set_risultato(int x){
risultato = x;
}
public void Start_Operation(int x){
Operazioni op = new Operazioni();
op.start(x);
}
private int var1;
private int var2;
private int risultato;
}
public class Operazioni extends Calc{
public start(int x){
if(x==000){
int a = super.Get_Var1();
int b = super.Get_Var2();
int c = a+b;
super.Set_risultato(c);
}
if(x==001){
.......................................
..............................
}
}}
Il problema è che la classe 'Calc' richiama perfettamente la classe 'Operazioni' e i suoi metodi, ma i valori dei campi istanza della classe 'Calc' che è in esecuzione non vengono modificati!!!!!!! :cry:
C'è qualcuno in grado di aiutarmi...?? :help:
bottomap
31-10-2005, 11:50
Ciao,
Non mi è ben chiaro quali e quante classi hai in esecuzione in un dato momento...
Quando istanzi un Operazione essa "contiene" (per usare un termine bruttissimo) un Calc con tutte le sue variabili istanza... tali variabili vengono modificate con i metodi Get e Set che hai scritto nella classe di base...
Posta, casomai, il codice del main che utilizza la classe in questione... magari troviamo più agevolmente il problema...
PS: Visto che anche i metodi vengono ereditati da Operazione (e non vengono ridefiniti) non è necessario specificare super.
Ciaociao :)
Ciao!
Bè, postare il codice ufficiale del main è un problemino....poichè il programma "vero" è incapsulato nel suo frontend! :D
Comunque ci provo!....:
QUESTO è IL CODICE DELLA CLASSE PRINCIPALE:
/*
* Kernel_Calc.java
*
* Created on 3 ottobre 2005, 13.39
*/
package progetto_mp;
import java.io.*;
/**
*
* @author Fabrizio
*/
public class Kernel_Calc {
/** Creates a new instance of Calc */
public Kernel_Calc() {
//Inizializzo a '0' il contenuto della RAM
for(int t=0; t<=RAM.length -1; t++){
//Inizializza a 'zero' tutte le celle della RAM
RAM[t] = "0000000000000";
}
//Inizializzo a '0' il ProgramCounter
PC2 = 0;
//Inizializzo a '0' l'Accumulatore
ACC = "0000000000000";
//Inizializzo a '0' l'Instruction_Register
IR ="0000000000000";
try {
jbInit();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/************************************Metodi************************************/
/*Visualizza il contenuto dell'accumulatore
*/
public String View_ACC(){
return ACC;
}
/*Visualizza il contenuto dell'Instruction_Register
*/
public String View_IR(){
return IR;
}
/*Visualizza il contenuto del Program_Counter
*/
public String View_PC(){
return convertitore.aBinario(PC2);
}
/*Visualizza il contenuto della RAM
*/
public String View_RAM(){
String appoggio= "";
for(int s=0; s<=RAM.length-1; s++){
appoggio += (RAM[s]+"\n");
}
return appoggio;
}
/*restituisce il contenuto della RAM in una determinata cella
*/
public String Get_RAM(int x){
return RAM[x];
}
/*restituisce il contenuto dell'Instruction_Register
*/
public String Get_IR(){
return IR;
}
/*restituisce il contenuto del Program_Counter
*/
public int Get_PC(){
return PC2;
}
/*consente di modificare l'Instruction_Register
*/
public void Set_IR(String x){
IR = x;
}
/*consente di modificare il Program_Counter
*/
public void Set_PC(int x){
PC2 = x;
}
/****************************************************************************************************************/
/*restituisce il nome del metodo associato al codice operativo
*/
public void Get_Metodo(String x){
Operazioni op = new Operazioni();
op.start(x);
}
public void Set_RAM(int t, String x){
RAM[t]=x;
}
public void Set_ACC(String x){
ACC=x;
}
/********************************************************************************/
/*Legge il file di input che gli viene fornito dall'utente
*/
public int lettura_file(File file){
int y=0;
try{
int t=0;
int flag1=0, flag2=0;
BufferedReader in = new BufferedReader(new FileReader(file));
String line;
while((line = in.readLine())!=null){
if(line.length()==13){
}else{
return 3;
}
for(int h=0; h<=line.length()-1; h++){
if(line.charAt(h)=='0' || line.charAt(h)=='1'){
}else{
return 3;}
}
int istruzione = convertitore.daBinario(line.substring(0, 5));
int indirizzo=convertitore.daBinario(line.substring(5, 13));
if(istruzione <= 9 || istruzione == 31){
}else{ flag1 = 1;}
if(indirizzo <= 256){
}else {flag2 = 1;}
}
BufferedReader in2 = new BufferedReader(new FileReader(file));
if(flag1==0){
if(flag2==0){
y = 10;
while((line = in2.readLine())!= null){
RAM[t] = line;
t++;
}
}else{return 1;}
}else{return 2;}
}catch (IOException e)
{
e.printStackTrace();
}
return y;
}
/*********************************Campi Istanza********************************/
//Ram
private String RAM[] = new String[256];
//Accumulatore
private String ACC;
//Program_Counter
private int PC2=0;
//Instruction_Register
private String IR;
private String Input="";
String Output="";
private void jbInit() throws Exception {
}
}
Questo è il codice della classe contenenti i metodi che devono modificare i valori dei campi istanza della classe pricipale:
public class Operazioni extends Kernel_Calc {
/** Creates a new instance of Operazioni */
public Operazioni() {
}
public void start(String x){
//ADDIZIONE
if(x.substring(0, 5).equals("00100")){
/*Addiziona il valore memorizzato nella cella il cui indirizzo è memorizzato
*nella parte operando dell'istruzione all'accumulatore, memorizzando il
*risultato nell'accumulatore. Se il risultato richiede più di 13 bit,
*nell'accumulatore viene scritto il valore '0'
*/
//prelevo l'indirizzo della cella della RAM contenente il valore da sommare
int indirizzo = convertitore.daBinario(x.substring(5, 13));
//converto in numero decimale il valore binario contenuto nella cella della RAM il cui indirizzo è stato precedentemente ricavato
int var1 = convertitore.daBinario(super.Get_RAM(indirizzo));
//converto in numero decimale il valore binario contenuto nell'Accumulatore
int var2 = convertitore.daBinario(super.View_ACC());
int somma = var1+var2;
//coverto la 'somma' ottenuta in un valore-binario
String ris = convertitore.aBinario(somma);
//se il risultato "in binario" non ha una lunghezza di 13bit viene azzerato l'Accumulatore
if(ris.length()<=13){
super.Set_ACC(ris);
}else { super.Set_ACC("0");}
System.out.println("DEBUG: "+super.Get_PC());
}
//HALT
if(x.substring(0, 5).equals("11111")){
/*Scrive nel Program Counter il valore '0' e termina il programma
*/
super.Set_PC(0);
}
}
}
bottomap
31-10-2005, 12:32
Ciao,
"A naso" il problema sta qui:
public void Get_Metodo(String x)
{
Operazioni op = new Operazioni();
op.start(x);
}
Questa funzione della classe base crea un nuovo oggetto operazioni (che "contiene", come detto) una classe base... l'oggetto in questione è completamente scollegato dalla classe chiamante... per cui le variabili istanza che vengono modificate sono quelle di op, e non quelle della classe chiamante.
Dopo op.start probabilmente, se vuoi mantenere questa struttura del programma, dovrai copiare nelle variabili della classe quelle di op... var1=op.var1, var2=op.var2, eccetera...
Ciaociao :)
Hai perfettamente centrato il problema! :)
Inoltre il programma in questione è quasi ultimato e quindi non ho modo di rimodificarne la struttura per ridefinire un'ereditarietà più "ortodossa"!
Quindi metterò dei valori di ritorno dalla casse Operazioni alla Kernel_Calc.
Comunque, a titolo informativo, quale dovrebbe essere la struttura 'corretta' per
realizzare l'ereditarietà del mio programma?
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.