Hi, sorry for delay.
Despite my great interest in this task, I can not spend a lot of time on
the project. But you're right, everything I've posted on go-nuts shows that
conversion is very possible and in the same context that you're
considering, if I understand you correctly of course . So far it looks like
this:
syntactic analysis,
semantic analysis,
then there is code generation on Go from AST.
Regards,
четверг, 18 августа 2022 г. в 21:58:03 UTC+3, Oliveira Jose Carlos de -
ICTS BSA:
> Hi, I´m looking foward to find a Tool able to convert any Java Source code
> Project to a GoLang Project. I know that are Programming languages created
> for different propposal. Java is OOL and goLang is different. So
> convertion is possible, but I think is very complex. For me is much more
> easy look on Java Source code logic and write your own code in GoLang. I
> think....
>
> I did it in the past, and writting code in a new language make de new code
> more maintenable.
>
> Em domingo, 22 de maio de 2022 às 03:49:42 UTC-3, alex-coder escreveu:
>
>> So, channels.
>> Converter can now convert Java classes to Go channels where possible. The
>> previous example contains a Drop class that matches the conversion
>> criteria, as shown in the Go example code below. Accordingly, if the
>> converter "does not find" a class suitable for conversion, Java
>> multithreading will be converted to Go code without using the translation
>> into channels.
>> *Java code:*
>> package com.builder.start.here;
>>
>> import java.util.Random;
>>
>> public class RunMe {
>> public static void main(String[] args) {
>> Drop drop = new Drop();
>> (new Thread(new Producer(drop))).start();
>> (new Thread(new Consumer(drop))).start();
>> }
>> }
>> class Drop {
>> // Message sent from producer
>> // to consumer.
>> private String message;
>> // True if consumer should wait
>> // for producer to send message,
>> // false if producer should wait for
>> // consumer to retrieve message.
>> private boolean empty = true;
>>
>> public synchronized String take() {
>> // Wait until message is
>> // available.
>> while (empty) {
>> try {
>> wait();
>> } catch (InterruptedException e) {}
>> }
>> // Toggle status.
>> empty = true;
>> // Notify producer that
>> // status has changed.
>> notifyAll();
>> return message;
>> }
>>
>> public synchronized void put(String message) {
>> // Wait until message has
>> // been retrieved.
>> while (!empty) {
>> try {
>> wait();
>> } catch (InterruptedException e) {}
>> }
>> // Toggle status.
>> empty = false;
>> // Store message.
>> this.message = message;
>> // Notify consumer that status
>> // has changed.
>> notifyAll();
>> }
>> }
>> class Consumer implements Runnable {
>> private Drop drop;
>>
>> public Consumer(Drop drop) {
>> this.drop = drop;
>> }
>>
>> public void run() {
>> Random random = new Random();
>> for (
>> String message = drop.take();
>> ! message.equals("DONE");
>> message = drop.take()) {
>> System.out.format(
>> "MESSAGE RECEIVED: %s%n", message);
>> try {
>> Thread.sleep(random.nextInt(5000));
>> } catch (InterruptedException e) {}
>> }
>> }
>> }
>> class Producer implements Runnable {
>> private Drop drop;
>>
>> public Producer(Drop drop) {
>> this.drop = drop;
>> }
>>
>> public void run() {
>> String importantInfo[] = {
>> "Mares eat oats",
>> "Does eat oats",
>> "Little lambs eat ivy",
>> "A kid will eat ivy too"
>> };
>> Random random = new Random();
>>
>> for (int i = 0; i < importantInfo.length; i++) {
>> drop.put(importantInfo[i]);
>> try {
>> Thread.sleep(random.nextInt(5000));
>> } catch (InterruptedException e) {}
>> }
>> drop.put("DONE");
>> }
>> }
>>
>> *Converter gave out:*
>>
>> package main
>>
>> import (
>> "fmt"
>> "math/rand"
>> "os"
>> "sync"
>> "time"
>> )
>>
>> type RunMe struct{}
>>
>> func NewRunMe() *RunMe {
>> var runMe RunMe = RunMe{}
>> return &runMe
>> }
>> func main() {
>> var args []string = os.Args
>> var rm *RunMe = NewRunMe()
>> rm.RunMe_main(&args)
>> }
>> /** generated method **/
>> func (runMe *RunMe) RunMe_main(args *[]string) {
>> wg := &sync.WaitGroup{}
>> var drop chan string = make(chan string)
>>
>> wg.Add(1)
>> go (&Thread{NewProducer(drop)}).run(wg)
>> wg.Add(1)
>> go (&Thread{NewConsumer(drop)}).run(wg)
>> wg.Wait()
>> }
>> type Consumer struct {
>> drop chan string
>> }
>> func NewConsumer(drop chan string) *Consumer {
>>
>> var consumer Consumer = Consumer{drop}
>> return &consumer
>> }
>> func (consumer *Consumer) run(wg *sync.WaitGroup) {
>> defer wg.Done()
>> var random *Random = NewRandom()
>> for message := <-consumer.drop;
>> message != "DONE";
>> message = <-consumer.drop {
>>
>> fmt.Printf("MESSAGE RECEIVED: %s\n", message)
>> time.Sleep(random.nextInt(5000))
>> }
>> }
>> type Producer struct {
>> drop chan string
>> }
>> func NewProducer(drop chan string) *Producer {
>>
>> var producer Producer = Producer{drop}
>> return &producer
>> }
>> func (producer *Producer) run(wg *sync.WaitGroup) {
>> defer wg.Done()
>> var importantInfo [4]string = [4]string{
>> "Mares eat oats",
>> "Does eat oats",
>> "Little lambs eat ivy",
>> "A kid will eat ivy too"}
>> var random *Random = NewRandom()
>> for i := 0; i < len(importantInfo); i++ {
>> producer.drop <- (importantInfo[i])
>> time.Sleep(random.nextInt(5000))
>> }
>> producer.drop <- ("DONE")
>>
>> }
>>
>> type Random struct{}
>> func NewRandom() *Random {
>> var random Random = Random{}
>> return &random
>> }
>> func (r *Random) nextInt(n int) time.Duration { return
>> time.Duration(rand.Intn(n)) }
>> type Thread struct {
>> Runnable
>> }
>> func (t *Thread) run(wg *sync.WaitGroup) {
>> t.Runnable.run(wg)
>> }
>> type Runnable interface {
>> run(wg *sync.WaitGroup)
>> }
>>
>> You can run code there:
>> Go Playground <https://go.dev/play/p/-y6f_rOa4EX>
>>
>> Now I'll take a break, I need to deal with the advices that I received.
>>
>> Thank you to all very much.
>> среда, 18 мая 2022 г. в 13:43:07 UTC+3, alex-coder:
>>
>>> Henry,
>>> thank you, it is quite possible that you are right, at least I should
>>> check it out.
>>> Thank you again.
>>>
>>> среда, 18 мая 2022 г. в 07:39:49 UTC+3, Henry:
>>>
>>>> Kudos to you. Java to Go is a lot of work. Java is a more complex
>>>> language. It has more features and more possibilities for expressing the
>>>> same model/algorithm. You need to identify all these possibilities, parse,
>>>> and convert them to Go. I could be wrong about this, but it may be easier
>>>> to convert Java bytecode to Go.
>>>>
>>>> On Tuesday, May 17, 2022 at 9:49:09 PM UTC+7 alex-coder wrote:
>>>>
>>>>> In Go, multithreading is one of the main features, respectively, the
>>>>> ability to convert Java code using multithreading into Go code
>>>>> automatically, which uses channels, is very important.
>>>>> I found a suitable example of ProducerConsumerExample from Oracle
>>>>> there:Oracle sample
>>>>> <https://docs.oracle.com/javase/tutorial/essential/concurrency/guardmeth.html>,
>>>>>
>>>>> where the Drop class is a candidate for conversion to Go using channels.
>>>>> But, now I give an intermediate result without channels.
>>>>> Also, I read the opinion that the conversion of Java code where
>>>>> annotations are used in runtime is impossible. It is necessary to
>>>>> investigate the problem and try to understand if it is possible to solve
>>>>> it
>>>>> somehow. Before transferring a project from the status of "possibility of
>>>>> achievement" to the status of "prototype", it is necessary to see what
>>>>> can
>>>>> be done with these problems in relation to annotations.
>>>>> *Java code:*
>>>>> package com.builder.start.here;
>>>>>
>>>>> import java.util.Random;
>>>>>
>>>>> public class RunMeDrop {
>>>>>
>>>>> public static void main(String[] args) {
>>>>> Drop drop = new Drop();
>>>>> (new Thread(new Producer(drop))).start();
>>>>> (new Thread(new Consumer(drop))).start();
>>>>> }
>>>>> }
>>>>> class Drop {
>>>>> // Message sent from producer
>>>>> // to consumer.
>>>>> private String message;
>>>>> // True if consumer should wait
>>>>> // for producer to send message,
>>>>> // false if producer should wait for
>>>>> // consumer to retrieve message.
>>>>> private boolean empty = true;
>>>>>
>>>>> public synchronized String take() {
>>>>> // Wait until message is
>>>>> // available.
>>>>> while (empty) {
>>>>> try {
>>>>> wait();
>>>>> } catch (InterruptedException e) {}
>>>>> }
>>>>> // Toggle status.
>>>>> empty = true;
>>>>> // Notify producer that
>>>>> // status has changed.
>>>>> notifyAll();
>>>>> return message;
>>>>> }
>>>>>
>>>>> public synchronized void put(String message) {
>>>>> // Wait until message has
>>>>> // been retrieved.
>>>>> while (!empty) {
>>>>> try {
>>>>> wait();
>>>>> } catch (InterruptedException e) {}
>>>>> }
>>>>> // Toggle status.
>>>>> empty = false;
>>>>> // Store message.
>>>>> this.message = message;
>>>>> // Notify consumer that status
>>>>> // has changed.
>>>>> notifyAll();
>>>>> }
>>>>> }
>>>>> class Consumer implements Runnable {
>>>>> private Drop drop;
>>>>>
>>>>> public Consumer(Drop drop) {
>>>>> this.drop = drop;
>>>>> }
>>>>>
>>>>> public void run() {
>>>>> Random random = new Random();
>>>>> for (
>>>>> String message = drop.take();
>>>>> ! message.equals("DONE");
>>>>> message = drop.take()) {
>>>>> System.out.format(
>>>>> "MESSAGE RECEIVED: %s%n", message);
>>>>> try {
>>>>> Thread.sleep(random.nextInt(5000));
>>>>> } catch (InterruptedException e) {}
>>>>> }
>>>>> }
>>>>> }
>>>>> class Producer implements Runnable {
>>>>> private Drop drop;
>>>>>
>>>>> public Producer(Drop drop) {
>>>>> this.drop = drop;
>>>>> }
>>>>>
>>>>> public void run() {
>>>>> String importantInfo[] = {
>>>>> "Mares eat oats",
>>>>> "Does eat oats",
>>>>> "Little lambs eat ivy",
>>>>> "A kid will eat ivy too"
>>>>> };
>>>>> Random random = new Random();
>>>>>
>>>>> for (int i = 0; i < importantInfo.length; i++) {
>>>>> drop.put(importantInfo[i]);
>>>>> try {
>>>>> Thread.sleep(random.nextInt(5000));
>>>>> } catch (InterruptedException e) {}
>>>>> }
>>>>> drop.put("DONE");
>>>>>
>>>>> }
>>>>> }
>>>>>
>>>>> *Converter gave out:*
>>>>> package main
>>>>>
>>>>> import (
>>>>> "fmt"
>>>>> "math/rand"
>>>>> "os"
>>>>> "sync"
>>>>> "time"
>>>>> )
>>>>>
>>>>> type RunMe struct{}
>>>>>
>>>>> func NewRunMe() *RunMe {
>>>>> var runMe RunMe = RunMe{}
>>>>> return &runMe
>>>>>
>>>>> }
>>>>> func main() {
>>>>>
>>>>> var args []string = os.Args
>>>>> var rm *RunMe = NewRunMe()
>>>>> rm.RunMe_main(&args)
>>>>> }
>>>>>
>>>>> /** generated method **/
>>>>> func (runMe *RunMe) RunMe_main(args *[]string) {
>>>>> wg := &sync.WaitGroup{}
>>>>> var drop *Drop = NewDrop()
>>>>> wg.Add(1)
>>>>> go (&Thread{NewProducer(drop)}).run(wg)
>>>>> wg.Add(1)
>>>>> go (&Thread{NewConsumer(drop)}).run(wg)
>>>>> wg.Wait()
>>>>> }
>>>>>
>>>>> type Drop struct {
>>>>> /** generated field */
>>>>> cond *sync.Cond
>>>>> message *string
>>>>> empty *bool
>>>>> }
>>>>>
>>>>> func NewDrop() *Drop {
>>>>>
>>>>> var drop Drop = Drop{}
>>>>> drop.cond = sync.NewCond(&sync.Mutex{})
>>>>> empty := true
>>>>> drop.empty = &empty
>>>>> return &drop
>>>>> }
>>>>> func (drop *Drop) take() string {
>>>>> drop.cond.L.Lock()
>>>>> for *drop.empty {
>>>>> drop.cond.Wait()
>>>>> }
>>>>>
>>>>> *drop.empty = true
>>>>> drop.cond.L.Unlock()
>>>>> drop.cond.Broadcast()
>>>>> return *drop.message
>>>>> }
>>>>> func (drop *Drop) put(message *string) {
>>>>> drop.cond.L.Lock()
>>>>> for !*drop.empty {
>>>>> drop.cond.Wait()
>>>>> }
>>>>>
>>>>> *drop.empty = false
>>>>> drop.message = message
>>>>> drop.cond.L.Unlock()
>>>>> drop.cond.Broadcast()
>>>>> }
>>>>>
>>>>> type Consumer struct {
>>>>> drop *Drop
>>>>> }
>>>>>
>>>>> func NewConsumer(drop *Drop) *Consumer {
>>>>> var consumer Consumer = Consumer{drop}
>>>>> return &consumer
>>>>> }
>>>>> func (consumer *Consumer) run(wg *sync.WaitGroup) {
>>>>> defer wg.Done()
>>>>>
>>>>> var random *Random = NewRandom()
>>>>> for message := consumer.drop.take();
>>>>> message != "DONE";
>>>>> message = consumer.drop.take() {
>>>>> fmt.Printf("MESSAGE RECEIVED: %s\n", message)
>>>>> time.Sleep(random.nextInt(5000))
>>>>> }
>>>>> }
>>>>>
>>>>> type Producer struct {
>>>>> drop *Drop
>>>>> }
>>>>>
>>>>> func NewProducer(drop *Drop) *Producer {
>>>>> var producer Producer = Producer{drop}
>>>>> return &producer
>>>>> }
>>>>> func (producer *Producer) run(wg *sync.WaitGroup) {
>>>>> defer wg.Done()
>>>>>
>>>>> var importantInfo [4]string = [4]string{
>>>>> "Mares eat oats",
>>>>> "Does eat oats",
>>>>> "Little lambs eat ivy",
>>>>> "A kid will eat ivy too",
>>>>> }
>>>>>
>>>>> var random *Random = NewRandom()
>>>>> for i := 0; i < len(importantInfo); i++ {
>>>>> producer.drop.put(&importantInfo[i])
>>>>> time.Sleep(random.nextInt(5000))
>>>>> }
>>>>> s := "DONE"
>>>>> producer.drop.put(&s)
>>>>> }
>>>>>
>>>>> type Random struct{}
>>>>>
>>>>> func NewRandom() *Random {
>>>>> var random Random = Random{}
>>>>> return &random
>>>>> }
>>>>>
>>>>> func (r *Random) nextInt(n int) time.Duration {
>>>>> return time.Duration(rand.Intn(n))
>>>>> }
>>>>>
>>>>> type Thread struct {
>>>>> Runnable
>>>>> }
>>>>>
>>>>> func (t *Thread) run(wg *sync.WaitGroup) {
>>>>> t.Runnable.run(wg)
>>>>> }
>>>>>
>>>>> type Runnable interface {
>>>>> run(wg *sync.WaitGroup)
>>>>> }
>>>>> The Go Playground, you can run code there:
>>>>> Go Playground. <https://go.dev/play/p/o7tXt8p2m_3>
>>>>>
>>>>> Thank you to all very much.
>>>>>
>>>>> четверг, 28 апреля 2022 г. в 19:08:51 UTC+3, alex-coder:
>>>>>
>>>>>> So, multithreading.
>>>>>> I found a simple example from Oracle with the wonderful name "Bad
>>>>>> Threads" there:
>>>>>>
>>>>>> https://docs.oracle.com/javase/tutorial/essential/concurrency/QandE/questions.html
>>>>>>
>>>>>> , simplified it even more, called the example a new simple name One and
>>>>>> extend a Converter to translate the code to Golang.
>>>>>> There is no similar processing for InterruptedException in go, so the
>>>>>> Converter does not translate the processing of this interrupt in any
>>>>>> way.
>>>>>> If anyone has a relatively small example in Java, please share it.
>>>>>> *Java code:*
>>>>>> package run.me;
>>>>>> public class One {
>>>>>> String msg;
>>>>>> public static void main( String[] args) throws
>>>>>> InterruptedException {
>>>>>> One one=new One();
>>>>>> one.msg="Initial message";
>>>>>> System.out.println("main:before start:" + one.msg + " second part
>>>>>> of");
>>>>>> new Second(one).start();
>>>>>> one.msg="after go start";
>>>>>> Thread.sleep(2000);
>>>>>> System.out.println("main:about to end:" + one.msg);
>>>>>> }
>>>>>> }
>>>>>> class Second extends Thread {
>>>>>> One one;
>>>>>> public Second( One one){
>>>>>> this.one=one;
>>>>>> }
>>>>>> public void run(){
>>>>>> try {
>>>>>> sleep(1000);
>>>>>> } catch ( InterruptedException e) {
>>>>>> }
>>>>>> System.out.println("run:after sleep:" + one.msg);
>>>>>> one.msg="try to change msg";
>>>>>> }
>>>>>> }
>>>>>> *Converter выдал:*
>>>>>> package main
>>>>>>
>>>>>> import (
>>>>>> "fmt"
>>>>>> "os"
>>>>>> "time"
>>>>>> )
>>>>>>
>>>>>> type One struct {
>>>>>> msg *string
>>>>>> }
>>>>>>
>>>>>> func NewOne() *One {
>>>>>> var one One = One{}
>>>>>> return &one
>>>>>> }
>>>>>> func main() {
>>>>>> var args []string = os.Args
>>>>>> var o_dummy *One = NewOne()
>>>>>> o_dummy.One_main(&args)
>>>>>> }
>>>>>>
>>>>>> /** generated method **/
>>>>>> func (one_one *One) One_main(args *[]string) {
>>>>>> var one *One = NewOne()
>>>>>> s := "Initial message"
>>>>>> one.msg = &s
>>>>>> fmt.Println("main:before start:" + *one.msg + " second part of")
>>>>>> go NewSecond(one).run()
>>>>>> s_s := "after go start"
>>>>>> one.msg = &s_s
>>>>>> time.Sleep(2000)
>>>>>> fmt.Println("main:about to end:" + *one.msg)
>>>>>> }
>>>>>>
>>>>>> type Second struct {
>>>>>> one *One
>>>>>> }
>>>>>>
>>>>>> func NewSecond(one *One) *Second {
>>>>>> var second Second = Second{one}
>>>>>> return &second
>>>>>> }
>>>>>> func (second *Second) run() {
>>>>>> time.Sleep(1000)
>>>>>> fmt.Println("run:after sleep:" + *second.one.msg)
>>>>>> s_s_s := "try to change msg"
>>>>>> second.one.msg = &s_s_s
>>>>>> }
>>>>>>
>>>>>> The next example will probably be about channel's.
>>>>>> If anyone has an interesting example, write me, I'll think about how
>>>>>> to solve it. I just can't promise that it will be quickly. :-)
>>>>>>
>>>>>> Thank you to all !
>>>>>>
>>>>>> четверг, 7 апреля 2022 г. в 18:52:25 UTC+3, alex-coder:
>>>>>>
>>>>>>> Thanks for the comments about generating code to handle exceptions.
>>>>>>> . Here it is a new version.
>>>>>>> package main
>>>>>>>
>>>>>>> import (
>>>>>>> "fmt"
>>>>>>> "os"
>>>>>>> )
>>>>>>>
>>>>>>> type CatchException struct{}
>>>>>>>
>>>>>>> func main() {
>>>>>>>
>>>>>>> var args []string = os.Args
>>>>>>>
>>>>>>> var ce CatchException = CatchException{}
>>>>>>> ce.CatchException_main(args)
>>>>>>> }
>>>>>>>
>>>>>>> /** generated method **/
>>>>>>> func (catchException *CatchException) CatchException_main(args
>>>>>>> []string) {
>>>>>>> defer func() {
>>>>>>> if err := recover(); err != nil {
>>>>>>> exc := err.(Exception)
>>>>>>> switch exc.msg {
>>>>>>>
>>>>>>> case "Exception":
>>>>>>> fmt.Println("yes, I caught it")
>>>>>>> default:
>>>>>>> fmt.Println("No, something is not right")
>>>>>>> }
>>>>>>> }
>>>>>>> fmt.Println("finally processing")
>>>>>>> }()
>>>>>>>
>>>>>>> (&ThrowException{}).runme()
>>>>>>> }
>>>>>>>
>>>>>>> type ThrowException struct{}
>>>>>>>
>>>>>>> func (throwException *ThrowException) runme() {
>>>>>>> panic(Exception{"Exception"})
>>>>>>> }
>>>>>>>
>>>>>>> type Exception struct {
>>>>>>> msg string
>>>>>>> }
>>>>>>>
>>>>>>> понедельник, 4 апреля 2022 г. в 14:12:37 UTC+3, alex-coder:
>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> *Another use case for automatically translating codewritten in Java
>>>>>>>> to Golang is Exception Handling.The next example is likely to be about
>>>>>>>> multithreading.Example in Java:*
>>>>>>>> package com.builder.start.here;
>>>>>>>>
>>>>>>>> public class CatchException {
>>>>>>>>
>>>>>>>> public static void main(String[] args) {
>>>>>>>> try {
>>>>>>>> new ThrowException().runme();
>>>>>>>> } catch (Exception e) {
>>>>>>>> System.out.println("yes, I caught it");
>>>>>>>> } finally {
>>>>>>>> System.out.println("finally processing");
>>>>>>>> }
>>>>>>>>
>>>>>>>> }
>>>>>>>>
>>>>>>>> }
>>>>>>>>
>>>>>>>> class ThrowException{
>>>>>>>> public void runme() throws Exception{
>>>>>>>> throw new Exception();
>>>>>>>> }
>>>>>>>> }
>>>>>>>>
>>>>>>>> *Converter gave out:*
>>>>>>>>
>>>>>>>> package main
>>>>>>>>
>>>>>>>> import (
>>>>>>>> "fmt"
>>>>>>>> "os"
>>>>>>>> )
>>>>>>>>
>>>>>>>> type CatchException struct{}
>>>>>>>>
>>>>>>>>
>>>>>>>> func main() {
>>>>>>>>
>>>>>>>> var args []string = os.Args
>>>>>>>>
>>>>>>>> var ce CatchException = CatchException{}
>>>>>>>> ce.CatchException_main(args)
>>>>>>>> }
>>>>>>>>
>>>>>>>> /** generated method **/
>>>>>>>> func (catchException *CatchException) CatchException_main(args
>>>>>>>> []string) {
>>>>>>>> defer func() {
>>>>>>>> if err := recover(); err != nil {
>>>>>>>> str := err.(string)
>>>>>>>> switch str {
>>>>>>>> case "Exception":
>>>>>>>> fmt.Println("yes, I caught it")
>>>>>>>> default:
>>>>>>>> fmt.Println("No, something is not right")
>>>>>>>> }
>>>>>>>> }
>>>>>>>> fmt.Println("finally processing")
>>>>>>>> }()
>>>>>>>>
>>>>>>>> (&ThrowException{}).runme()
>>>>>>>> }
>>>>>>>>
>>>>>>>> type ThrowException struct{}
>>>>>>>>
>>>>>>>> func (throwException *ThrowException) runme() {
>>>>>>>> panic("Exception")
>>>>>>>> }
>>>>>>>> воскресенье, 27 марта 2022 г. в 15:11:48 UTC+3, alex-coder:
>>>>>>>>
>>>>>>>>> After several months of switching from Java to Golang, it seemed
>>>>>>>>> to me that
>>>>>>>>> it would be interesting to make the translation of Java code into
>>>>>>>>> Golang automatically.
>>>>>>>>> The text below shows what has been done so far.
>>>>>>>>>
>>>>>>>>> The work is not a prototype, but rather indicates the possibility
>>>>>>>>> of achieving a result.
>>>>>>>>> Therefore, I deliberately simplify the development context of the
>>>>>>>>> Converter where it was
>>>>>>>>> possible.
>>>>>>>>>
>>>>>>>>> At first it seemed important to me that between Java and Go there
>>>>>>>>> is a difference
>>>>>>>>> between the implementation of the Dynamic Dispatching, more
>>>>>>>>> precisely, there is no
>>>>>>>>> Dynamic Dispatching in Go. The applied solution in the current
>>>>>>>>> implementation
>>>>>>>>> looks not only ugly but even violates the several very important
>>>>>>>>> rules of the OO design,
>>>>>>>>> I'm not kidding here. But this option looks like that it will be
>>>>>>>>> working.
>>>>>>>>>
>>>>>>>>> Onward I will provide the 4 code samples in Java, followed by the
>>>>>>>>> automatically
>>>>>>>>> generated Golang code and comments as needed.
>>>>>>>>>
>>>>>>>>> *1. Of course, I started with the most popular program: "Hello
>>>>>>>>> World".*
>>>>>>>>>
>>>>>>>>> package main;
>>>>>>>>>
>>>>>>>>> public class HelloWorld {
>>>>>>>>> public static void main( String[] args){
>>>>>>>>> System.out.println("Hello World");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *Converter gave out:*
>>>>>>>>>
>>>>>>>>> package main
>>>>>>>>>
>>>>>>>>> import (
>>>>>>>>> "fmt"
>>>>>>>>> "os"
>>>>>>>>> )
>>>>>>>>>
>>>>>>>>> type HelloWorld struct{}
>>>>>>>>>
>>>>>>>>> func main() {
>>>>>>>>>
>>>>>>>>> var args []string = os.Args
>>>>>>>>>
>>>>>>>>> var hw HelloWorld = HelloWorld{}
>>>>>>>>> hw.HelloWorld_main(args)
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> /** generated method **/
>>>>>>>>> func (helloWorld *HelloWorld) HelloWorld_main(args []string) {
>>>>>>>>> fmt.Println("Hello World")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *2. Next, it was interesting to deal with the problem of a simple
>>>>>>>>> inheritance.*
>>>>>>>>>
>>>>>>>>> package main;
>>>>>>>>>
>>>>>>>>> public class TestInheritance {
>>>>>>>>> public static void main( String[] args){
>>>>>>>>> Inheritance inh=null;
>>>>>>>>> inh=new Second();
>>>>>>>>> inh.hello();
>>>>>>>>> inh=new Third();
>>>>>>>>> inh.hello();
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> public interface Inheritance {
>>>>>>>>> public void hello();
>>>>>>>>> }
>>>>>>>>> class Second implements Inheritance {
>>>>>>>>> public void hello(){
>>>>>>>>> System.out.println("Second");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> class Third implements Inheritance {
>>>>>>>>> public void hello(){
>>>>>>>>> System.out.println("Third");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *Converter gave out:*
>>>>>>>>>
>>>>>>>>> package main
>>>>>>>>>
>>>>>>>>> import (
>>>>>>>>> "fmt"
>>>>>>>>> "os"
>>>>>>>>> )
>>>>>>>>>
>>>>>>>>> type TestInheritance struct{}
>>>>>>>>>
>>>>>>>>> func main() {
>>>>>>>>>
>>>>>>>>> var args []string = os.Args
>>>>>>>>>
>>>>>>>>> var ti TestInheritance = TestInheritance{}
>>>>>>>>> ti.TestInheritance_main(args)
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> /** generated method **/
>>>>>>>>> func (testInheritance *TestInheritance) TestInheritance_main(args
>>>>>>>>> []string) {
>>>>>>>>>
>>>>>>>>> var inh Inheritance
>>>>>>>>> inh = AddressSecond(Second{})
>>>>>>>>> inh.hello()
>>>>>>>>> inh = AddressThird(Third{})
>>>>>>>>> inh.hello()
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type Inheritance interface {
>>>>>>>>> hello()
>>>>>>>>> }
>>>>>>>>> type Second struct{}
>>>>>>>>>
>>>>>>>>> func (second *Second) hello() {
>>>>>>>>> fmt.Println("Second")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type Third struct{}
>>>>>>>>>
>>>>>>>>> func (third *Third) hello() {
>>>>>>>>> fmt.Println("Third")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func AddressSecond(s Second) *Second { return &s }
>>>>>>>>> func AddressThird(t Third) *Third { return &t }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *3. In the following example, it is necessary to correctly define
>>>>>>>>> a common interface for the inheritance tree.*
>>>>>>>>>
>>>>>>>>> package no.packeges;
>>>>>>>>>
>>>>>>>>> public class TestExtension {
>>>>>>>>> public static void main( String[] args){
>>>>>>>>> TestExtension te=new TestExtension();
>>>>>>>>> te.hello();
>>>>>>>>> te=new Second();
>>>>>>>>> te.hello();
>>>>>>>>> te=new Third();
>>>>>>>>> te.hello();
>>>>>>>>> te=new Fourth();
>>>>>>>>> te.hello();
>>>>>>>>> }
>>>>>>>>> public void hello(){
>>>>>>>>> System.out.println("hello");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> class Second extends TestExtension {
>>>>>>>>> public void hello(){
>>>>>>>>> System.out.println("Second");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> class Third extends TestExtension {
>>>>>>>>> public void hello(){
>>>>>>>>> System.out.println("Third");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> class Fourth extends Third {
>>>>>>>>> public void hello(){
>>>>>>>>> System.out.println("Fourth");
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *Converter gave out:*
>>>>>>>>>
>>>>>>>>> package main
>>>>>>>>>
>>>>>>>>> import (
>>>>>>>>> "fmt"
>>>>>>>>> "os"
>>>>>>>>> )
>>>>>>>>>
>>>>>>>>> type TestExtension struct{}
>>>>>>>>>
>>>>>>>>> func main() {
>>>>>>>>>
>>>>>>>>> var args []string = os.Args
>>>>>>>>>
>>>>>>>>> var te TestExtension = TestExtension{}
>>>>>>>>> te.TestExtension_main(args)
>>>>>>>>> }
>>>>>>>>> func (testExtension *TestExtension) hello() {
>>>>>>>>> fmt.Println("hello")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> /** generated method **/
>>>>>>>>> func (testExtension *TestExtension) TestExtension_main(args
>>>>>>>>> []string) {
>>>>>>>>>
>>>>>>>>> var te ITestExtension =
>>>>>>>>> AddressTestExtension(TestExtension{})
>>>>>>>>> te.hello()
>>>>>>>>> te = AddressSecond(Second{})
>>>>>>>>> te.hello()
>>>>>>>>> te = AddressThird(Third{})
>>>>>>>>> te.hello()
>>>>>>>>> te = AddressFourth(Fourth{})
>>>>>>>>> te.hello()
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type Second struct {
>>>>>>>>> TestExtension
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func (second *Second) hello() {
>>>>>>>>> fmt.Println("Second")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type Third struct {
>>>>>>>>> TestExtension
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func (third *Third) hello() {
>>>>>>>>> fmt.Println("Third")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type Fourth struct {
>>>>>>>>> Third
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func (fourth *Fourth) hello() {
>>>>>>>>> fmt.Println("Fourth")
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type ITestExtension interface {
>>>>>>>>> /** Generated Method */
>>>>>>>>> hello()
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func AddressSecond(s Second) *Second { return
>>>>>>>>> &s }
>>>>>>>>> func AddressThird(t Third) *Third { return
>>>>>>>>> &t }
>>>>>>>>> func AddressTestExtension(t TestExtension) *TestExtension { return
>>>>>>>>> &t }
>>>>>>>>> func AddressFourth(f Fourth) *Fourth { return
>>>>>>>>> &f }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *4. Now the Dynamic Dispatching absence. The problematic method in
>>>>>>>>> the last sample is the amount() in class Repeater. Without
>>>>>>>>> rewriting
>>>>>>>>> the code, I think it would be impossible to invoke it correctly.*
>>>>>>>>>
>>>>>>>>> package main;
>>>>>>>>>
>>>>>>>>> public class Speaker {
>>>>>>>>> String message;
>>>>>>>>> public static void main( String[] args){
>>>>>>>>> Speaker sp = new Speaker("Say hello !");
>>>>>>>>> System.out.println(sp.amount());
>>>>>>>>> sp.speak();
>>>>>>>>> Repeater rp = new Repeater("Say hello !",3);
>>>>>>>>> System.out.println(rp.amount());
>>>>>>>>> rp.speak();
>>>>>>>>> }
>>>>>>>>> public Speaker( String message){
>>>>>>>>> this.message=message;
>>>>>>>>> }
>>>>>>>>> public void speak(){
>>>>>>>>> for (int i=0; i < amount(); i++) {
>>>>>>>>> System.out.println(this.message);
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> public int amount(){
>>>>>>>>> return 1;
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> class Repeater extends Speaker {
>>>>>>>>> int to_repeat=0;
>>>>>>>>> public Repeater( String message, int amount){
>>>>>>>>> super(message);
>>>>>>>>> this.to_repeat=amount;
>>>>>>>>> }
>>>>>>>>> public int amount(){
>>>>>>>>> return this.to_repeat;
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *Converter gave out:*
>>>>>>>>>
>>>>>>>>> package main
>>>>>>>>>
>>>>>>>>> import (
>>>>>>>>> "fmt"
>>>>>>>>> "os"
>>>>>>>>> )
>>>>>>>>>
>>>>>>>>> type Speaker struct {
>>>>>>>>> message string
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func main() {
>>>>>>>>>
>>>>>>>>> var args []string = os.Args
>>>>>>>>>
>>>>>>>>> var s_dummy Speaker = NewSpeaker("")
>>>>>>>>> s_dummy.Speaker_main(args)
>>>>>>>>> }
>>>>>>>>> func NewSpeaker(message string) Speaker {
>>>>>>>>>
>>>>>>>>> var speaker Speaker = Speaker{message}
>>>>>>>>> return speaker
>>>>>>>>> }
>>>>>>>>> func (speaker *Speaker) speak() {
>>>>>>>>> for i := 0; i < speaker.amount(); i++ {
>>>>>>>>> fmt.Println(speaker.message)
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> func (speaker *Speaker) amount() int {
>>>>>>>>> return 1
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> /** generated method **/
>>>>>>>>> func (speaker *Speaker) Speaker_main(args []string) {
>>>>>>>>>
>>>>>>>>> var sp ISpeaker = AddressSpeaker(NewSpeaker("Say hello !"))
>>>>>>>>> fmt.Println(sp.amount())
>>>>>>>>> sp.speak()
>>>>>>>>>
>>>>>>>>> var rp ISpeaker = AddressRepeater(NewRepeater("Say hello
>>>>>>>>> !", 3))
>>>>>>>>> fmt.Println(rp.amount())
>>>>>>>>> rp.speak()
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type Repeater struct {
>>>>>>>>> Speaker
>>>>>>>>>
>>>>>>>>> to_repeat int
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func NewRepeater(message string, amount int) Repeater {
>>>>>>>>>
>>>>>>>>> var repeater Repeater = Repeater{NewSpeaker(message),
>>>>>>>>> amount}
>>>>>>>>> return repeater
>>>>>>>>> }
>>>>>>>>> func (repeater *Repeater) amount() int {
>>>>>>>>> return repeater.to_repeat
>>>>>>>>> }
>>>>>>>>> func (repeater *Repeater) speak() {
>>>>>>>>> for i := 0; i < repeater.amount(); i++ {
>>>>>>>>> fmt.Println(repeater.message)
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> type ISpeaker interface {
>>>>>>>>>
>>>>>>>>> /** Generated Method */
>>>>>>>>>
>>>>>>>>> amount() int
>>>>>>>>> /** Generated Method */
>>>>>>>>>
>>>>>>>>> speak()
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> func AddressRepeater(r Repeater) *Repeater { return &r }
>>>>>>>>> func AddressSpeaker(s Speaker) *Speaker { return &s }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *5. I will be thankful for any feedback. Thanks to everyone.*
>>>>>>>>>
>>>>>>>>
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/golang-nuts/100feb87-3a53-49b7-b09e-94fb5330cde6n%40googlegroups.com.
