Introduction

This article is written using claw44.
This is a study note when studying the basics from zero to some extent.
Since I write what I have studied casually, the content is abundant and not very organized.

reference

▼ Things that you might forget / make mistakes

Describe one class per file.
File name and class name should be in the same case.
The indent is `4 blanks``.
Class variables are marked with static.
Access to instance variables is this.variable
Access to class variables is class name.variable name
It seems that variables are called fields.

▼ Naming convention

Basic

Numbers cannot be used as the first letter
Case sensitive

name of the class

Pascal method
PermissionsIntro
AsyncTask
FileCopy
MainActivity

Method name

Common

camelCase method (lower camel Case)
sendFile()
checkVersion()

method that returns a boolean variable

Name the method so that it represents a proposition
is + adjective
has + past participle
can + verb
Example
isEmpty()
hasChanged()
canAccess()

Variable name

camelCase method (lower camel Case)
count
errorMsg

constant

All uppercase snake case
MAX_LENGTH
DIR_PATH

Convenient symmetry word list

add / remove
insert / delete
get / set
start / stop
begin / end
send / receive
first / last
get / release
put / get
up / down
show / hide
source / target
open / close
source / destination
lock / unlock
old / new
next / previous

▼ How to use quotation marks properly

' is used for one character
" Use for strings

▼ Types of variables and how to define them

Data type

1 character for char type
String type is a character string. Only String, the first letter is uppercase.
The long type is like an int type with a large capacity. Add "L" to the end of the value.
The float type is like a double type with a large capacity. Add "F" to the end of the value.

char a = 'a';
String s = "hello world!";

int i = 10;
long l = 10000000L;

double d = 234.222;
float f = 234.987F;

Reference type

Array

int[] array;
array = new int[3];

int[] array;
array = new int[] {100, 200, 300};

int[] array = {100, 200, 300};

▼ Check the length of the array

int i = array.length;

▼ Output to command line

Standard output

System.out.println();  //With line breaks
System.out.print();    //No line breaks

Error output

System.err.println();  //With line breaks
System.err.print();    //No line breaks

▼ Increment decrement operator

Exists. (It didn't exist in ruby ...)

x++;
x--;

x += 1;
x -= 1;

▼ Type conversion

Number ⇒ character string

String s = String.valueOf(i);

Character string ⇒ numbers

int i = Integer.parseInt(s);

Integer ⇔ floating point

double d = (double)i;

int i = (int)d;

▼ Control statement

Leave a space between ʻif` and the parentheses of the condition.

if (conditions){
     //processing
} else if (conditions){
     //processing
} else {
}

switch

switch(variable){
case value 1:
        //processing
        //Process when the value of the variable is "value 1".
        break;

case value 2:
case value 3:
        //processing
        //Process when the value of the variable is "value 2" or "value 3".
        break;

    default:
        //processing
        break;
}

▼ Ternary operator

conditions?Return value when positive:Return value in case of mistake;

Example:
String msg = i > 80 ? "good" : "so so...";

▼ Repeat statement (loop)

Common

break; ⇒ Exit the loop.
continue; ⇒ Go through the current loop times and proceed to the next loop times.

while

while (conditions){
    //processing
}

do while

do {
    //processing
} while (conditions)

for

for (int i = 0; i < 10; i++){
    //processing
}

Extension for

String[] names = {"Fujiwara", "Sakai", "Daiwa"};

for (String name : names) {
    System.out.println(name);
}

▼ Modifier

stroke order

Target	Order
field	public protected private static final transient volatile
Method	public protected private abstract static final synchronized native strictfp
class	public protected abstract static final strictfp

Access modifier

Access modifier	Description
private	Only accessible from the same class
protected	Accessable from current class and subclass
None	Accessable from a class in the same package as the current class
public	Accessable from anywhere

static modifier

Class variables / methods with static
Without static, instance variables / methods
** Instance variables cannot be accessed from static methods. ** **

final modifier

Variable ⇒ Cannot be changed
Class ⇒ Cannot be inherited
Method ⇒ Cannot be overridden.

abstract modifier

Used when creating abstract classes and methods.

▼ Mezzot

How to declare

Qualifier Return type method name(argument){
Method processing
}

public static void SayHello(){
    //processing
}

Main method

Declaration

    public static void main(String[] args){
      
    }

Method overload

Multiple definitions can be made with the same method name if the number and type of arguments are different. The system looks at the number and type of arguments to determine which method definition to use.

public class MyApp{

    public static void sayHi(String name){
        System.out.println("Hi! " +name);
    }

    public static void sayHi(){
        System.out.println("Hi! Nobody");
    }

    public static void main(String[] args){
        sayHi("Jones"); // Hi! Jones
        sayHi();        // Hi! Nobody
    }
}

Method override

Overwrite the one defined in the inheritance class

public class User {

    public void hello() {
        System.out.println("Hello World!");
    }
}

public class AdminUser extends User {

    @Override  //Annotation
    public void hello() {
        System.out.println("Hello World override!");
    }
}

Abstract method

Methods defined in the abstract class
If you do not override this method in a class that inherits the abstract class, you will get an error.

▼ Class

Declaration

Qualifier class class name{
  
}

class User {
  
}

Instantiation

User jones = new User();

Inheritance

If you create class B by inheriting class A, you can use the method defined in class A in class B.

class User {
    void sayHi(){
        System.out.println("hi!");
    }
}

class AdminUser extends User {
}

Abstract class

Leave the implementation to the concrete class. It's just a definition.
Rules that do not instantiate abstract classes directly.

▼ Calling variables

Description	Description
`Variable name`	Calling local variables
`this.Variable name`	Calling instance variables ⇒ At the time of declaration`static`Variables not attached
`name of the class.Variable name`	Calling class variables ⇒ At the time of declaration`static`The one I put on

▼ Constructor

Basic

The one that is called when you do new class name ().
Define with class name ()

//Access class name(){}
//You don't need a return type because you can't return a return value

public class User{
    public User(String name){
        //processing
    }
}

this()

Also, this () written in the class means a constructor. It can be used when calling the constructor somewhere in the class. Or when overloading the constructor.

class User{
    private String name;
    User(String name){
        this.name = name;
    }
    
    User() {
        this("no name");
    }
    
}

super()

You can now call the constructor of the parent class.
Only available on the first line of the constructor.

public class User {
    protected String name;

    public User(String name){
        this.name = name;
    }
}

public class AdminUser extends User {

    public AdminUser(){
        super("AdminUser desu");                // User(String name){}call
        //Special processing only for child class here
    }
}

(Class) Initializer

When executed when the class is objectified.

class User {
    private static int count; //Class variables

    static {
        User.count = 0;
    }
}

(Instance) Initializer

Called before the constructor when the class is instantiated.

class User {
    private static int count; //Class variables

     {
        System.out.println("Instant Initializer")
    }
}

▼ Package

Directory structure

`Construction`


/(root)
├── README.md
└── com
    └── dotinstall
        └── myapp
            ├── MyApp.java
            └── model
                ├── AdminUser.java
                └── User.java

Declaration

If you write the following at the beginning, the java file will be recognized as part of the package.

`MyApp.java`


package com.dotinstall.myapp.model;

import

You can import the java file in the package by writing as follows.

`MyApp.java`


import com.dotinstall.myapp.model.User;

If you want to import all java files in Package, follow below.

`MyApp.java`


import com.dotinstall.myapp.modem.*;

▼ interface

The variable described in interface is forcibly given with public, static and final.
In the interface, public and ʻabstract are added to the methodwritten withno qualifier`.
If you add the default modifier when describing the class, you can write the processing of the method. (public)
It seems that static method is also applied. (public)

Declaration

interface Printable {
    double VERSION = 1.2;       //constant
    void print();               //Abstract method
    default void getInfo() {}   //default method
    static static_method() {}   //static method
}

How to use

class User implements Printable {
}

▼ Enumeration type (enum)

Sample code

enum Fruit {
    Banana(1, "Philippines"),
    Apple(2, "Aomori"),
    Orange(3, "Ehime");

    private int id;
    private String pref;

    private Fruit(int id, String pref) {
        this.id = id;
        this.pref = pref;
    }

    public int getId() {
        return this.id;
    }
    public String getPref() {
        return this.pref;
    }
}

valueOf()

    Fruit frt;
    frt = Fruit.Apple;

    if (frt == Fruit.valueOf("Apple")) {
        //processing
    }

values()

for (Fruit frt : Fruit.values()) {
    System.out.println(frt.getPref());
}

▼ Exception handling

Own exception class definition

Extend the Exception class.
An error message can be set in the constructor of the Exception class.

class MyException extends Exception {
    public MyException() {
        super ("error message");
    }
}

When deciding the error message at the time of throw ↓

class MyException extends Exception {
    public MyException(String errorMessage) {
        super (errorMessage);
    }
}

Call your own exception class

If you have defined an error message in the constructor.

if (b < 0) {
    throw new MyException();
}

If you want to insert an error message when throwing.

if (b < 0) {
    throw new MyException("error message");
}

Error handling (try / catch / finally)

try {

    } catch (ArithmeticException e) { //Error class+Variable name
        //processing
    } catch (MyException e) {         //Error class+Variable name
        //processing
    } finally {
        //processing
}

▼ Wrapper Class

FIXME

Omitted

▼ Generics

FIXME
Somehow, the variable type such as the argument is made undefined so that the variable type can be selected when the Class is converted to Instance. It seems.
It seems that constant types such as ʻintanddouble cannot be used, and only reference types such as ʻInteger and Double can be used.
When I looked it up, it seemed to be very deep, so I gave up looking it up.

class MyData<T> {
    public void printIt(T x) {
        System.out.println(x);
    }
}

public class MyApp{


    public static void main (String[] args){

            MyData<Integer> i = new MyData<>();
            i.printIt(29);
    }
}

▼ Thread / Multi Thread

FIXME
It's nice to learn more.

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.print('.');
        }
    }
}


public class MyApp{


    public static void main (String[] args){
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();

        for (int i = 0; i < 500; i++) {
            System.out.print('+');
        }

    }
}

▼ Anonymous class

Omit Interface implementation class? Do not define.
If you use it only once, don't you bother to define it?
I haven't tried it, but it seems that the same thing can be done not only with Interface but also with superclasses. (Declare a concrete class and instantiate it at the same time.)

interface Foo {
    void sampleMethod();
}

public class MyApp{
    public static void main (String[] args){
        Foo unNamed = new Foo() {                    //Here, of the class that implements Foo
            @Override                                //Definition and instantiation
            public void sampleMethod(){              //It is done at the same time.
                System.out.println("print it!");     // (Foo is an interface.)
            }
        };

        unNamed.sampleMethod();
    }
}

▼ Lambda expression / functional interface

This can only be used with ** interfaces with one abstract method **.
FIXME

interface Foo {
    void sampleMethod(String text);          //Abstract method definition
}


public class MyApp{
    public static void main (String[] args){

        Foo rambda = (text) -> {             //Concrete method definition
            System.out.println(text);        //I'll do it here.
        };

        rambda.sampleMethod("do it !");
    }
}

▼ math / random

FIXME
Omitted

▼ ArrayList

ʻImport java .util. *; You need to do `.
add to. It's a list that can be deleted.

import java.util.*;

public class MyApp{
    public static void main (String[] args){

        List<Integer> sales = new ArrayList<>();

        sales.add(10);
        sales.add(20);
        sales.add(30);

        for (Integer i = 0; i < sales.size(); i++) {
            System.out.println(sales.get(i));
        }

        for (Integer sale : sales) {
            System.out.println(sale);
        }
    }
}

▼ HashSet

FIXME

import java.util.*;

public class MyApp{
    public static void main (String[] args){

        Set<Integer> sales = new HashSet<>();

        sales.add(10);
        sales.add(20);
        sales.add(30);

        for (Integer sale : sales) {
            System.out.println(sale);
        }
    }
}

▼ HashMap

FIXME

  import java.util.*;
  
  public class MyApp{
      public static void main (String[] args){
  
          Map<String, Integer> students = new HashMap<>();
  
          students.put("uta", 80);
          students.put("jones", 60);
          students.put("tatsuya", 70);
  
          students.remove("jones");
  
          System.out.println(students.get("tatsuya"));
          System.out.println(students.size());
  
          for (Map.Entry<String, Integer> student : students.entrySet()) {
              System.out.println(student.getKey() + ':' + student.getValue());
          }
  
      }
  }

[Java] Study notes

reference

Contents

▼ Things that you might forget / make mistakes

▼ Naming convention

Basic

name of the class

Method name

Common

method that returns a boolean variable

Variable name

constant

Convenient symmetry word list

▼ How to use quotation marks properly

▼ Types of variables and how to define them

Data type

Reference type

Array

▼ Check the length of the array

▼ Output to command line

Standard output

Error output

▼ Increment decrement operator

▼ Type conversion

Number ⇒ character string

Character string ⇒ numbers

Integer ⇔ floating point

▼ Control statement

▼ Ternary operator

▼ Repeat statement (loop)

Common

Extension for

▼ Modifier

stroke order

Access modifier

static modifier

final modifier

abstract modifier

▼ Mezzot

How to declare

Main method

Method overload

Method override

Abstract method

▼ Class

Declaration

Instantiation

Inheritance

Abstract class

▼ Calling variables

▼ Constructor

Basic

(Class) Initializer

(Instance) Initializer

▼ Package

Construction

Declaration

MyApp.java

MyApp.java

MyApp.java

Declaration

How to use

▼ Enumeration type (enum)

Sample code

▼ Exception handling

Own exception class definition

Call your own exception class

Error handling (try / catch / finally)

▼ Anonymous class

▼ Lambda expression / functional interface

`Construction`

`MyApp.java`

`MyApp.java`

`MyApp.java`