Java SE Bronze (1Z0-818) Passing Experience

Introduction

This is Qiita's first post. After changing jobs in July of this year due to inexperienced development work, I am working at a development company in Osaka. In this exam, I wanted to prove as a visible form how much I had acquired Java knowledge, and I tried the qualification exam with the aim of improving the basic skills of Java.

My specs

--Former infrastructure operator --Java inexperienced (of course, no development practice) --I have touched PHP a little

Precautions for application

--The application procedure is quite complicated --Note the test name
First of all, there is an article that is easier to understand than I explain about "the application procedure is quite complicated", so please refer to this article.
This article Was also very helpful in taking the exam, so I will share it.

Next, regarding "Note the exam name", if you already know it, the exam "Java SE 7/8 Bronze (1Z0-814)" will be delivered on 7/31 of this year (2020). Is finished. You can check it by following this link.
** Please note that the test name of the successor version is "Java SE Bronze (1Z0-818)" **. In the search window of Pearson VUE ** 1 Z0-818 alone will hit the search **

Period (learning time)

――About 2 weeks ――6-9 hours on weekdays (There are other tasks, so there are some variations) --About 5 hours on holidays --Total: About 80 to 110 hours
In my bad place, I tend to be lazy because I have time. He is a useless person who is finally impatient when the deadline is approaching. It may be good to decide the period first for everything (self-discipline)
My advice is that if you can secure a certain amount of study time on weekdays and holidays, 2 weeks (1 week for Dekir) is enough.
Let's calculate back from the period you set and study every day!

Learning method

-[Reference book (purple book)](https://www.amazon.co.jp/%E3%82%AA%E3%83%A9%E3%82%AF%E3%83%AB%E8%AA % 8D% E5% AE% 9A% E8% B3% 87% E6% A0% BC% E6% 95% 99% E7% A7% 91% E6% 9B% B8-Java% E3% 83% 97% E3% 83 % AD% E3% 82% B0% E3% 83% A9% E3% 83% 9E-Bronze-SE-% E5% B1% B1% E6% 9C% AC / dp / 4798142719) --Learning until you can understand the areas you are not good at (Qiita articles, etc.) --Actually write the code, put the debugger and follow the process
Only the above three points.
I did a total of about 3 laps of purple books, but I should have solved a problem that I hadn't solved yet, because I could keep it for about 2 laps and use a different book on the internet.
Also, in my case I was struggling with "overload override" and "nesting for statements" problems, so every time I stumbled upon a problem, I googled and actually wrote and debugged the code to understand the program flow. I was doing it.

Last check

• [ ] JVM
  ** Read class file **
  Interpret and execute ** bytecode written in the class file ** (execute the class file)
  ** Memory management **
  
  -[] Identifier
  The first character of an identifier (variable, method, class, etc.) is only ** alphabetic characters (a ~ z, A ~ Z), ($), (_) **
  Numbers are possible after 2 letters
  There is no limit on the number of characters
  
  -[] char type
  The char type is one character that can be expressed in Unicode (16 bits), and is ** distinguished from a character string **
  The char type can handle unsigned integers (1 or 5)
  ** If you want to store Unicode value in char type, enclose it in single quotes (') **
  If enclosed in double quotes ("), it will be a character string.
  
  -[] Default value of basic data type
  Integer value: 0
  Floating point type: 0.0
  boolean type: false
  char type: ** \ u0000 **
  Reference type: null
  
  -[] if statement
  In the if statement, {} may be omitted if there is only one line to process.
  However, if you describe processing of two or more lines, it will be executed regardless of the result of the conditional expression.
  
  -[] switch statement
  The result of the expression of the switch statement is one of the values , ** short **, ** int **, ** enum **, ** char **, ** String ** as the data type. Need to be (it seems better to check at the beginning of the problem)
  
  -[] while statement
  Writing while (false) will result in a compile error
  
  -[] Extended for statement
  If the data types of the variable declaration and the variable of the reference variable name are not matched, a compile error will occur.
  ** Variable declaration must be declared in the for statement **. Declaring outside will result in a compile error
  
  -[] Constructor
  The constructor name is the same as the class name
  All access modifiers can be specified
  ** Return value **, ** void **, ** abstract **, ** static **, ** final ** cannot be specified
  ** Note that if you specify a return value, it will be a method instead of a constructor **.
  ** Not inherited by subclass **
  
  -[] Member
  When the class is instantiated, the instance member will ** have individual space in the case object .
  Even if multiple static members are instantiated, ** an area is secured in one place **
  
  -[] Access between members
  Instance member-> Direct access to static member is OK
  Static member-> Direct access to instance member is NG
  Must be instantiated for static access
  
  -[] Access modifiers / modifiers
  public and default: ** class ** · ** constructor ** · ** variable ** · ** method **
  protected and private: ** Constructor ** / ** Variable ** / ** Method ** ( Not available for abstract methods **. ** To override in subclass **.)
  Local variables and control statements (if, for): ** Access modifiers cannot be specified **
  abstract modifier: Cannot be used for ** constructor ** / ** variable **
  static modifier: ** Variable ** / ** Method only **
  
  -[] final modifier
  Variable-> constant
  Method-> Cannot be overridden on the subclass side
  Class-> Inheritance is not possible
  ** Constructor-> Cannot be used **
  
  -[] public class
  One public class per file
  If you define a public class, make the file name the same
  
  -[] Overload
  ** Method name (constructor name) ** is the same
  ** Argument sequence **, ** Argument type **, ** Number of arguments ** must be different
  
  -[] Override
  ** Signature (method name and argument list) ** is the same
  If the return value is the same, or if it is a subclass of its ** return type **, it is considered an override.
  The access modifier must be ** the same as the superclass ** or ** wider than that **
  ** Instance methods (non-static methods) cannot be overridden by static methods **
  
  -[] Inheritance
  Subclasses can inherit ** variables **, ** methods **
  Constructor is not inherited
  The Java language only supports single inheritance, so you can only specify one class after the ** extends keyword **
  When you instantiate a class (subclass) that has an inheritance relationship, ** always execute from the superclass constructor ** and the subclass constructor is executed
  If you do not explicitly specify the constructor you want to call on the subclass side, the constructor that implicitly has no superclass arguments will be called with ** super () **.
  
  -[] Abstract class
  ** An abstract class that inherits an abstract class does not cause an error even if the abstract method defined in the superclass is not implemented (overridden) **. However, if the inheritance destination is a concrete class, it needs to be implemented
  ** Cannot be instantiated **
  
  -[] Interface
  When declaring a variable in an interface, it becomes a static constant ** public static final **, so it must be initialized at the same time as the declaration.
  You must always add ** public ** to override abstract methods when implementing an interface
  When using extends and implements together, write ** extends ** first
  Abstract methods cannot have static modifiers
  
  -[] Package
  When hierarchizing package names, separate the hierarchy names with dots <.>
  
  -[] Package / Compile / Execute
  Backslash <> When compiling the source files in the package
  Dot connection when executing
  
  -[] Package public
  To allow classes other than the package to which you belong to use your own class, add ** public ** to the permitted class name and method name.

One last word

I am relieved that I managed to write so far. While I was writing, I had some recollections about the exam and qualification learning, so I will tell you about them at the end.
First of all, regarding qualification learning It is important to get used to the problem by going through the reference book many times, but I felt that it is more important to be able to solve the problem in "1 minute or less (ideally 50 seconds)" (1 in the exam). Q 1 minute pace is required). Also, as others have said, it is no exaggeration to say that the degree of understanding of the "overload override" problem is directly linked to pass / fail.
Regarding the test production, I feel more nervous than I expected in the actual performance, so my reading comprehension is much lower than usual (I was so nervous for the first 5 minutes that I wasn't so nervous (laughs)). It's hard to say that you're not nervous, but please relax as much as possible and hope for the exam.

That's it. Next is Java Silver.