It all started when I tried to inherit classes in Python. From the perspective of myself, who has been dealing with Java so far, I thought, "What's this !!!!!!", so in some programming languages I compared the description method of class inheritance with the description method & behavior of the constructor.
Write, compare, view, and express your impressions around Java.
I used paiza.IO to check the operation. Convenient. https://paiza.io/ja
--Parent class (Super class) --A default constructor is available. Output the character string of "★ Parent constructor" to the console --Prepare one function / method --Output the character string passed as an argument to the console --Child class (inheriting class) --Inherit the Parent class --A default constructor is available. Output the character string of "☆ Child constructor" to the console --Prepare one function / method --Output the character string passed as an argument to the console --Call the function / method of Super class with the character string "★ Parent function / method can be called" as an argument. --Main class / main script (execution source) --In paiza.IO, the name of the Java execution source (including the main method) class must be Main, and this name --Instantiate the Child class -Call the child class function / method with the character string "☆ Child function / method can be called" as an argument.
Java Personally, it's the most familiar language. The version is Java 12.
Parent.java
public class Parent {
public Parent(){
System.out.println("★ Parent constructor");
}
protected void parentMethod(String message){
System.out.println(message);
}
}
Child.java
public class Child extends Parent{
public Child(){
System.out.println("☆ Child constructor");
}
public void childMethod(String message){
System.out.println(message);
parentMethod("★ You can call the Parent method");
}
}
Main.java
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.childMethod("☆ You can call the Child method");
}
}
★ Parent constructor ☆ Child constructor ☆ You can call the Child method ★ You can call the Parent method
--How to write class inheritance and constructor that suits you best personally --The default constructor of the parent class is also implicitly called --Multiple constructors with different arguments can be implemented
Python Next, the opportunity to write this article. The version is Python 3.6.8.
** class ** * Inheriting class * ** (** * Super class * **): **
** def \ _ \ _ init \ _ \ _ (self ** *, if any argument * **): ** ** Initial value setting process for instance self **
** def \ _ \ _ new \ _ \ _ (cls ** *, if any argument * **): ** ** return super (). \ _ \ _ New \ _ \ _ (cls ** *, if any argument * **) **
** * The following samples, execution results (console), and impressions are about the \ _ \ _ init \ _ \ _ function. ** **
parent.py
class Parent(object):
def __init__(self):
print('★ Parent constructor')
def parent_function(self, message):
print(message)
child.py
from parent import Parent
class Child(Parent):
def __init__(self):
print('☆ Child constructor')
def child_function(self, message):
print(message)
Parent.parent_function(self, '★ You can call the Parent function')
main.py
from child import Child
def main():
ch = Child()
ch.child_function('☆ You can call the child function')
if __name__ == '__main__':
main()
☆ Child constructor ☆ You can call the child function ★ You can call the Parent function
―― "Well, do you use parentheses in class inheritance? Isn't it wrong with the argument?" --Because Python treats everything as an object? --The \ _ \ _ init \ _ \ _ function of the Parent class is overwritten by the \ _ \ _ init \ _ \ _ function of the Child class. --When the \ _ \ _ init \ _ \ _ function of the Child class is deleted and executed, "★ Parent constructor" is output. --If you also want to execute the \ _ \ _ init \ _ \ _ function of the Parent class, it seems that you need to make it explicit as follows.
child.py
from parent import Parent
class Child(Parent):
def __init__(self):
Parent.__init__(self) #Added here! !! !! !! !! !!
print('☆ Child constructor')
def child_function(self, message):
print(message)
Parent.parent_function(self, '★ You can call the Parent function')
-Only one \ _ \ _ init \ _ \ _ function can be prepared in one class --Can't be Java-like --If you want multiple constructors, it seems better to use the default arguments - https://qiita.com/miyashiiii/items/9dcb2114ac0843a73fce
Initially, I only mentioned the \ _ \ _ init () \ _ \ _ function, Since I received comments, I also investigated the \ _ \ _ new \ _ \ _ function.
-** \ _ \ _ new \ _ \ _ function works ** when instantiating, so it works before ** \ _ \ _ init \ _ \ _ function . - \ _ \ _ init \ _ \ _ function works ** after the instance is created
Below is from the Python 3.7.4 documentation.
When implementing the \ _ \ _ new \ _ \ _ function, you need return super () .__ new __ (cls [, ...]).
https://docs.python.org/ja/3/reference/datamodel.html#object.new
In a typical implementation, when creating a new instance of a class, specify the appropriate arguments for super (). \ _ \ _ New \ _ \ _ (cls [, ...]) and \ _ for the super class. Call the \ _new \ _ \ _ () method to make the necessary changes to the newly created instance before returning it.
It was written properly (´ ・ ω ・ ｀) https://docs.python.org/ja/3/reference/datamodel.html#object.init
Called after the instance is created (by \ _ \ _ new \ _ \ _ ()) and before it is returned to the caller. The arguments are what you pass to the class's constructor expression. If both the base class and its derived class have \ _ \ _ init \ _ \ _ () methods, then the derived class's \ _ \ _ init \ _ \ _ () method is the base class's \ _ \ _ init \ _ \ _ ( ) You must explicitly call the method to ensure that the base class part of the instance is properly initialized. For example, super (). \ _ \ _ Init \ _ \ _ ([args ...]).
It seems that the \ _ \ _ new \ _ \ _ function was better if it was lined up with the Java constructor. ..
When I replaced the sample implemented by the \ _ \ _ init \ _ \ _ function with the \ _ \ _ new \ _ \ _ function as it is, The execution result (console) is as follows. ☆ Child constructor ★ Parent constructor ☆ You can call the child function ★ You can call the Parent function
Ruby By the mysterious logic that Python and Ruby. The version is Ruby 2.6.3.
** class ** * Inheriting class * ** <** * Super class * end
** def initialize (** * if any argument * **) ** end
parent.rb
class Parent
def initialize()
puts "★ Parent constructor"
end
def parent_function(message)
puts message
end
end
child.rb
require("./parent.rb")
class Child < Parent
def initialize()
puts "☆ Child constructor"
end
def child_function(message)
puts message
parent_function("★ You can call the Parent function")
end
end
main.rb
require("./child.rb")
child = Child.new
child.child_function("☆ You can call the child function")
☆ Child constructor ☆ You can call the child function ★ You can call the Parent function
――It seems like a description that conveys the feeling of inheritance of the class. It's Python-like that the constructor is a function with a fixed name
--Similar to Python, the initialize function of the Parent class is overwritten by the initialize function of the Child class.
--When the initialize function of Child class is deleted and executed, "★ Parent constructor" is output.
--With super, also execute Parent's initialize function
child.rb
require("./parent.rb")
class Child < Parent
def initialize()
super() #Added here! !! !! !! !! !!
puts "☆ Child constructor"
end
def child_function(message)
puts message
parent_function("★ You can call the Parent function")
end
end
--Only one initialize function can be prepared for each class --This is also similar to Python --Similarly, if you want multiple constructors, it seems better to use the default arguments. - https://blog.goo.ne.jp/korokoro-2/e/d62a1c524beecfe3dd6a8ce8c9dab257
PowerShell In the training for new employees at the company, there was a theme to create a PowerShell script, so I included it. There was no class inheritance in PowerShell (Kiri), so I was thinking of making it a punch line ... **. ** ** This was not on paiza.IO, so I checked the operation on my PC.
** class ** * Inheriting class * : ** * Super class * ** { }
parent.psm1
class Parent {
Parent() {
write-host("★ Parent constructor")
}
parent_function([String] $message) {
write-host($message)
}
}
child.ps1
using module ".\parent.psm1"
class Child : Parent {
Child(){
write-host("☆ Child constructor")
}
child_function([String] $message) {
write-host($message)
([Parent]$this).parent_function("★ You can call the Parent function")
}
}
main.ps1
. .\child.ps1
$child = [Child]::new()
$child.child_function("☆ You can call the child function")
★ Parent constructor ☆ Child constructor ☆ You can call the child function ★ You can call the Parent function
--For class inheritance, "colon?" The constructor is Java-like
--Like Java, the constructor of the Parent class is also implicitly called
--Similar to Java, multiple constructors with different arguments can be implemented.
――I tried to end it with "Well, it's Java-like", but ** it doesn't work **
-** Class inheritance across files is not straightforward **
--The Super class file should be a module file (extension is **. Psm1 ) and called with ʻusing module. ――I have to change the extension ... why? ?? ?? -** Super class functions can only be called by "casting the inheriting class $ this` with the Super class "
--Cast this ... why? ?? ??
Other than Java, Python, Ruby, and PowerShell were "I've written but never used classes" choices. I thought I'd try a couple of other programming languages that I hadn't touched before. I'm sorry, I'm exhausted with PowerShell.
paiza.IO has many programming languages that can be used, so If I feel better, I would like to add it if I try other things. ** Anyway, paiza.IO is really convenient. ** **
Compare how to write It was fun to understand the characteristics of each programming language and the looseness of my understanding! Thank you for staying with us until the end.
Recommended Posts