ఆబ్జెక్ట్ శ్రేణిని సేవ్ చేస్తోంది

"హలో, అమిగో! ఈ రోజు మనం మరొక ఆసక్తికరమైన అంశం గురించి నేర్చుకుంటాము. ప్రత్యేకంగా, వస్తువులను సేవ్ చేయడం మరియు లోడ్ చేయడం (పునర్నిర్మించడం) . మనకు క్యాట్ క్లాస్ ఉందని అనుకుందాం:"

class Cat
{
 public String name;
 public int age;
 public int weight;
}

మరియు ఫైల్‌ను సేవ్ చేయడానికి మరియు లోడ్ చేయడానికి అనుకూలమైన యంత్రాంగాన్ని జోడించాలనుకుంటున్నాము.

మేము దీన్ని ఇలా చేయవచ్చు:

class Cat {
    public String name;
    public int age;
    public int weight;

    public void save(PrintWriter writer) throws Exception {
        writer.println(name);
        writer.println(age);
        writer.println(weight);
        writer.flush();
    }

    public void load(BufferedReader reader) throws Exception {
        name = reader.readLine();
        age = Integer.parseInt(reader.readLine());
        weight = Integer.parseInt(reader.readLine());
    }
}

"వావ్! అది చాలా సులభం! మేము ప్రతి ఆర్గ్యుమెంట్ యొక్క విలువలను ఒక్కొక్క పంక్తిపై వ్రాస్తాము. మేము ఫైల్‌ను లోడ్ చేసినప్పుడు, వాటిని ఒకే క్రమంలో చదువుతాము. ఇది సరైన పరిష్కారం."

"ధన్యవాదాలు, అమిగో. ఇప్పుడు మీరు ఈ తరగతుల సమూహం కోసం సేవ్ మరియు లోడ్ పద్ధతులను వ్రాయవచ్చు:"

class Cat
{
 public String name;
 public int age;
 public int weight;
}
class Dog
{
 public String name;
 public int age;
}
class Human
{
 public Cat cat;
 public Dog dog;
}

మీకు ఒక మానవ వస్తువు ఉంది, అందులో ఒక కుక్క మరియు ఒక పిల్లి ఉండవచ్చు.

"నా దగ్గర ఒక పరిష్కారం ఉంది:"

class Cat {
    public String name;
    public int age;
    public int weight;

    public void save(PrintWriter writer) throws Exception {
        writer.println(name);
        writer.println(age);
        writer.println(weight);
        writer.flush();
    }

    public void load(BufferedReader reader) throws Exception {
        name = reader.readLine();
        age = Integer.parseInt(reader.readLine());
        weight = Integer.parseInt(reader.readLine());
    }
}

class Dog {
    public String name;
    public int age;

    public void save(PrintWriter writer) throws Exception {
        writer.println(name);
        writer.println(age);
        writer.flush();
    }

    public void load(BufferedReader reader) throws Exception {
        name = reader.readLine();
        age = Integer.parseInt(reader.readLine());
    }
}

public class Human {
    public Cat cat;
    public Dog dog;

    public void save(PrintWriter writer) throws Exception {
        cat.save(writer);
        dog.save(writer);
    }

    public void load(BufferedReader reader) throws Exception {
        cat.load(reader);
        dog.load(reader);
    }
}

"ఇది చాలా మంచి పరిష్కారం. కానీ మనిషికి కుక్క ఉంటే కానీ పిల్లి లేకపోతే ఏమి జరుగుతుంది?"

శూన్య తనిఖీలు ఎక్కడ ఉన్నాయి?

"నేను ఇప్పుడు సరి చేస్తాను:"

public class Human {
    public Cat cat;
    public Dog dog;

    public void save(PrintWriter writer) throws Exception {
        if (cat != null)
            cat.save(writer);
        if (dog != null)
            dog.save(writer);
    }

    public void load(BufferedReader reader) throws Exception {
        cat = new Cat();
        cat.load(reader);
        dog = new Dog();
        dog.load(reader);
    }
}

"ఇది ఇప్పటికీ సరిగ్గా లేదు. మీకు రెండు లోపాలు ఉన్నాయి:"

1) ఒక వ్యక్తికి పిల్లి లేదా కుక్క ఉండకపోవచ్చు, కానీ లోడ్ పద్ధతిని పిలిచినప్పుడు అవి ఇప్పటికీ సృష్టించబడతాయి

2) మనం కుక్కను మాత్రమే సేవ్ చేస్తే, దానిని లోడ్ చేసినప్పుడు దాని డేటాను పిల్లి చదువుతుంది.

"సరే, నేను ఏమి చేయాలి?"

"మేము వేరియబుల్స్ రాయడాన్ని దాటవేయలేము, లేకుంటే చదివేటప్పుడు మాకు సమస్యలు వస్తాయి . సేవ్ ఆపరేషన్ సమయంలో శూన్యంగా ఉన్న వేరియబుల్స్ లోడ్ ఆపరేషన్ సమయంలో శూన్యానికి సెట్ చేయబడిందని మీరు నిర్ధారించుకోవాలి. ఇదిగో నా వెర్షన్:"

public class Human {
    public Cat cat;
    public Dog dog;

    public void save(PrintWriter writer) throws Exception {
        String isCatPresent = cat != null ? "yes" : "no";
        writer.println(isCatPresent);
        writer.flush();

        if (cat != null)
            cat.save(writer);

        String isDogPresent = dog != null ? "yes" : "no";
        writer.println(isDogPresent);
        writer.flush();

        if (dog != null)
            dog.save(writer);
    }

    public void load(BufferedReader reader) throws Exception {

        String isCatPresent = reader.readLine();
        if (isCatPresent.equals("yes")) {
            cat = new Cat();
            cat.load(reader);
        }

        String isDogPresent = reader.readLine();
        if (isDogPresent.equals("yes")) {
            dog = new Dog();
            dog.load(reader);
        }
    }
}

"అవును, నాకు ఈ పరిష్కారం ఇష్టం."

"అవును, బాగుంది."