平成25年度静岡県立大学公開講座
Javaで学ぶプログラミング基礎
第１回
第２回
第３回
第４回
JavaとJava仮想マシン
Java言語の概要
Javaプログラミングの基礎
コンソール・アプリケーション作成
Androidアプリケーション作成
Javaとは
Sun Microsystems によって開発された。
オブジェクト指向言語。
プラットホーム非依存。
一度ソースを書くと、UNIXでもWindowsでも動く。
文法は、CやC++から多くを引き継いでいる。
ライブラリも充実している。
ネットワークやセキュリティに配慮されている。
配布されているファイル
Javaのプログラムソース
Java実行環境(Java Runtime Environment; JRE)
Javaのプログラムを実行するのに必要。
自分の機種（WindowsとかLinuxとか）用が必要。
Windows用も無料で配布されています。
Java開発キット (Java Development Kit; JDK)
Javaの基本的なプログラムに必要。
自分の機種（WindowsとかLinuxとか）用が必要。
Windows用も無料で配布されています。
プラットホーム非依存
色んな環境で動かしたい！
テキストファイル。
public
public class
class Hello
Hello {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
System.out.println("Hello,
System.out.println("Hello, world!");
world!");
C言語の場合．．．
Windows用 UNIX用
それぞれの行が何を意味しているのかは、徐々に
やっていきます。
Windows
Linux
Javaの場合．．．
プログラムを書く
どれでも動く
それぞれ
用に書く
必要
}}
}}
プログラムを書く
その他
Java
Java
Java
実行環境 実行環境 実行環境
Windows
Linux
その他
C言語でのプログラム作成
①プログラムを書く
Windows用のソース
Linux用のソース
②コンパイルする
Windows用の
Cコンパイラ
Linux用の
Cコンパイラ
プログラマの領域
Windows用
実行ファイル
①プログラムを書く
②コンパイルする
Linux用
実行ファイル
実行
③実行する
Javaでのプログラム作成 その1
実行
Windows
プログラマの領域
③実行する
Linux
②コンパイルする
Windowsで
書いて
Linuxで実行
③実行する
とかもできる
Javaのプログラムのソース
Windows用の
Javaのコンパイラ
Linux用の
Javaのコンパイラ
Java仮想マシン用のバイトコード
Windows用の
Java実行環境上で
実行
Windows
Linux用の
Java実行環境上で
実行
Linux
Windows用の
Javaのコンパイラ
Linux用の
Javaのコンパイラ
Java仮想マシン用のバイトコード
Linux用の
Java実行環境上で
実行
Windows用の
Java実行環境上で
実行
Windows
Javaでのプログラム作成 その2
①プログラムを書く
Javaのプログラムのソース
Linux
Java仮想マシン
Java仮想マシンは、その名の Javaのプログラムのソース
通り、仮想の計算機。
Windows用
Linux用
Javaバイトコードは、Java仮
コンパイラ
コンパイラ
想マシン上で動作する。
Javaコンパイラは、バイトコー Java仮想マシン用の
バイトコード
ドを生成。
Windows用
Linux用
Java実行環境は、バイトコー
実行環境
実行環境
ドを、各プラットホーム用に翻
訳して実行。
Windows
Linux
コンパイルと実行 その1
コンパイルと実行
①プログラムを書く
Javaのプログラムのソース
テキストエディタとかで書く。
Windows用
Linux用
拡張子は .java。
コンパイラ
コンパイラ
つまり、test.java のように
なる。
Java仮想マシン用の
バイトコード
Windows用
実行環境
Windows
Linux用
実行環境
Linux
コンパイルと実行 その2
コンパイルと実行 その3
Javaのプログラムのソース
②コンパイル
Windows用
Linux用
コンソールで次のようにする
javac
javac ファイル名
ファイル名
コンパイラ
コンパイラ
test.java をコンパイルしたい Java仮想マシン用の
バイトコード
なら、
javac
javac test.java
test.java
Windows用
実行環境
拡張子が .class のファイルが
できる。
Windows
Javaのプログラムのソース
③実行
Windows用
Linux用
コンソールで次のようにする。
コンパイラ
java
java 拡張子無しのファイル名
拡張子無しのファイル名
Linux用
実行環境
test.class を実行したいなら、
java
java test
test
Linux
コンパイラ
Java仮想マシン用の
バイトコード
Windows用
実行環境
Windows
Linux用
実行環境
Linux
演習1の内容
演習1：コンパイルと実行
Hello World
ソースを置く場所の作成
1.
デスクトップで右クリックし、コンテクストメニューで
[新規作成]→[フォルダ] とし、Java というフォルダを
作成。
サンプルプログラム Hello World を入力し、コンパイ
ル、実行を行います。
どのようなファイルができるか、確認していきます。
流れ：
1. ファイルをおくフォルダの作成
2. テキストエディタで hello.java を入力、作成
3. コマンドプロンプト上で、hello.javaをコンパイル
4. コマンドプロンプト上で、hello を実行
コマンドプロンプトの立ち上げ
1.
2.
3.
左下のスタートボタン
を押す。
ファイルの検索でcmdと入力。出てきたcmdを実行。
黒いコマンドプロンプトが立ち上がります。
コマンドプロンプト上で、
cd
cd Desktop¥Java
Desktop¥Java
と入力してEnterキーを押す。
プロンプトが
c:¥Users¥ユーザー名¥Desktop¥Java
となっているか確認しましょう。
ソースの記述
1.
2.
テキストエディタでサンプルプログラム1を書きます。
実習室には、テキストエディタとしてサクラエディタ
がインストールされています。
Hello.java というファイル名で保存します。
Hello.txtではないので注意しましょう。
public
public class
class Hello
Hello {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
System.out.println("Hello,
System.out.println("Hello, world!");
world!");
}}
}}
コンパイル
1.
2.
フォルダ Java 内に、Hello.java があることを確認しま
しょう。
コマンドプロンプトで、次を入力・実行します。
javac
javac Hello.java
Hello.java
3.
エラーが出た場合は、ソースに誤入力がないかを
確認してみてください。
フォルダ Java 内に、Hello.class ができたことを確認
しましょう。
実行
1.
コマンドプロンプトで、次を入力・実行します。
java
java Hello
Hello
基本的なデータ型
画面に Hello Worldと出ます。
Javaとデータと変数
処理するには、処理するものを蓄えておく場所が必要。
変数
ものには、種類がある
データの型
Javaで使用できるデータ型
Javaで使用できるデータ型
boolean 型 ： true または faulse
char型
： 16bitのUnicode文字
byte型
： 8bit符号付き整数
short型
：16bit符号付き整数
int型
：32bit符号付き整数
long型
：64bit符号付き整数
float型
：32bit浮動小数点数
double型
：64bit浮動小数点数
変数の宣言
変数とは、"値を保存しておく箱"のようなものです。
入れられるものの種類が決まっています。
最初に「こういうのを入れる、こういう名前の箱を使う」と
いうことを書いておく必要があります。→宣言
記述方法
型
型
変数の代入、参照
例： ii == 10;
10;
宣言の時に、同時に値を代入することもできる。
int
int roop
roop == 10;
10;
変数名,
変数名, 変数名;
変数名;
記述例：
int
int roop;
roop;
演算 その1
色々な演算子が使用できる。
その他にも、ビット演算を行う演算子とかがある。
x & y ： x と y のビットごとのAND
x | y ： x と y のビットごとのOR
x ^ y ： x と y のビットごとのXOR
x << y ： x を y ビットだけ左シフト
x >> y ： x を y ビットだけ算術右シフト
x >>> y ： x を y ビットだけ論理右シフト
代入演算子
演算 その3
1 ： x++ ： xの値を評価後、インクリメント
2 ： ++x ： xの値をインクリメント後、評価
3 ： x-- ： xの値を評価後、ディクリメント
4 ： --x ： xの値をディクリメント後、評価
上の意味
1 ： y=x++ ： y=x; x=x+1; ： 値を渡してから、xに1を加える
2 ： y=++x ： x=x+1; y=x; ： xに1を加えてから、値を渡す
3 ： y=x-- ： y=x; x=x-1; ： 値を渡してから、xから1を引く
4 ： y=--x ： x=x-1; y=x; ： xから1を引いてから、値を渡す
変数に保存している値を参照したいとき（使用したいと
き）は、変数名をそのまま記述します。
演算 その2
算術演算子：
論理演算子：
x + y ： x と y の和
A && B ：AかつB
x - y ： x と y の差
A || B ：AもしくはB
x * y ： x と y の積
!A
：Aの否定
x / y ： x を y で割った商
x % y ： x を y で割った余り
関係演算子：
x < y ： x < y のとき真（1）、さもなければ偽(0)
x <= y ： x <= y のとき真（1）、さもなければ偽(0)
x > y ： x < y のとき真（1）、さもなければ偽(0)
x >= y ： x > y のとき真（1）、さもなければ偽(0)
x == y ： x = y のとき真（1）、さもなければ偽(0)
x != y ： x != y のとき真（1）、さもなければ偽(0)
インクリメントとディクリメント
インクリメント → 増加
ディクリメント → 減少
変数に値を保存することを代入と言います。
= で行う。 変数名 = 代入する値;
変数名 = 代入する値;
加算代入：
整数型の変数 i に2を加えて i に代入したい
i+=2;
i+=2;
他にも、減算代入（-=）、乗算代入（*=）、除算代入
（/=）等、一通りあります。
printlnメソッドとprintメソッド
標準出力への出力
標準出力に文字を出力するメソッド
System.out.print()
出力した後、改行しない。
System.out.println()
出力した後、改行する。
改行する・しないの違いがあるだけで、他は一緒。
基本的な使い方 その1
""で文字を囲む
文字列 Test Data を表示する例：
基本的な使い方 その2
System.out.println("Test
System.out.println("Test Data");
Data");
System.out.println("Test
System.out.println("Test Data
Data "" ++ t);
t);
int型の変数 t の値を表示する例：
そのまま、変数名を書けば OK
t+10の値を表示する例：
System.out.println(t
System.out.println(t ++ 10);
10);
値 100 を表示する例：
System.out.println(100);
System.out.println(100);
出力結果（t=10の場合）：
20
そのまま書くと、"100"と解釈して出力してくれる。
文字列と変数と値が+で並んでいる例：
System.out.println("Test
System.out.println("Test Data
Data "" ++ tt ++ 10);
10);
出力結果（t=10の場合）：
Test Data 10 10
2つの+は、どちらも
連結と解釈される
System.out.println("Test
System.out.println("Test Data");
Data");
System.out.println(t);
System.out.println(t);
System.out.println("Test
System.out.println("Test Data"
Data" ++ t);
t);
System.out.println(t+10);
System.out.println(t+10);
t=100*10;
t=100*10;
System.out.println(t+10);
System.out.println(t+10);
System.out.println("Test
System.out.println("Test Data
Data "" ++ (t
(t ++ 10));
10));
連結
括弧おかげで、
演算として解釈
ファイル名は
Sample02.java
public
public class
class Sample02{
Sample02{
public
public static
static void
void main(String[]
main(String[] args){
args){
int
int t=10;
t=10;
文字列と変数と値が+で並んでいる例：
出力結果（t=10の場合）：
Test Data 20
+ は演算と解釈される。
演習2：
サンプルプログラム2
色んな例
+ 記号で連結できる
出力結果（t=10の場合）：
Test Data 10
System.out.println(t);
System.out.println(t);
文字列 Test Data と整数型の変数 t の値を表示する
}}
}}
オブジェクト指向プログラミング
オブジェクト指向プログラミング
（基本編）
複数のオブジェクトがある。
それぞれのオブジェクトが処理を行う。
オブジェクト間でデータをやりとりする。
Javaと
オブジェクト指向プログラミング
設計図と実物
オブジェクトの動作を
どこかで書かないと...
Javaは、オブジェクトを駆使して記述する言語。
基本、多くがオブジェクト。
クラス、インスタンス、メソッド → 次のページから解説
理解するのは、結構、面倒です。
設計図を書いて、
それに基づいて
生成しよう
C言語は、関数を駆使して記述する言語。
基本的に、全部の命令は関数。
同じ動作をする
オブジェクトも
簡単に作れる
オブジェクトって何？
直感とJava編
オブジェクトって何？
直感編
概念とか設計図の世界
実物（オブジェクト）の世界
缶A
缶
できること
• 中身を出す
• 中身を入れる
中身 = ？？
何も言われないと
最初は空である
できること
• 中身を出す
• 中身を入れる
中身 = オレンジ色の液体
缶B
概念とか設計図の世界
変数
缶
コンストラクタ
中身 = 水色の液体
できること
• 中身を出す
• 中身を入れる
できること
• 中身を出す
• 中身を入れる
クラス
実物（オブジェクト）の世界
缶A
メソッド
中身 = オレンジ色の液体
できること
• 中身を出す
• 中身を入れる
中身 = ？？
何も言われないと
空である
Javaだと
インスタンス
と呼ぶ
缶B
中身 = 水色の液体
できること
• 中身を出す
• 中身を入れる
インスタンス
インスタンス
オブジェクトって何？
Java編
概念とか設計図の世界
変数
Test
実物（オブジェクト）の世界
Data1 contents = 10;
コンストラクタ
contests=0;
Javaのプログラムの構造
メソッド
• pushContents();
• popContests();
int contents;
Data2 contents = 20;
メソッド
• pushContents();
• popContests();
クラス
Javaだと
インスタンス
と呼ぶ
メソッド
• pushContents();
• popContests();
メソッド
インスタンス
プログラム
1つ以上のクラスを持ちます。
クラス
クラスは、変数とコンストラクタ、メ
変数の宣言
ソッドを伴っています。省略可能です。
メソッド main を持つクラスが、必ず
コンストラクタ
必要です。
メソッド
プログラムのファイル名と、mainを
持つクラス名は、一致している必要
クラス
があります。
変数の宣言
この main が実行されます
コンストラクタ
慣習として、クラス名は大文字から、
メソッド
メソッド名は小文字から初めます。
インスタンス
サンプル例１
Hello.java の場合： mainを持っているクラス名がHello
なので、ファイル名はHello.java
public
public class
class Hello
Hello {{
クラスの記述と
インスタンスの生成
クラスが持っている変数は無し
コンストラクタも無し
public
public static
static void
void main(String[]
main(String[] args)
args) {{
System.out.println("Hello,
System.out.println("Hello, world!");
world!");
}}
}}
メソッドはmainだけ
やりたいこと
外観
1. クラスを書く
2. インスタンスを生成する
3. 実際に使ってみる
サンプルプログラム2を作りながら見ていきましょう
3つの部分
01行目
03～14行目
17～26行目
01:
01:
02:
02:
03:
03:
04:
04:
05:
05:
06:
06:
07:
07:
08:
08:
09:
09:
10:
10:
11:
11:
12:
12:
13:
13:
14:
14:
15:
15:
16:
16:
17:
17:
18:
18:
19
19
20:
20:
21:
21:
22:
22:
23:
23:
24:
24:
25:
25:
26:
26:
27:
27:
import
importjava.lang.String;
java.lang.String;
class
classHelloClass{
HelloClass{
String
Stringname;
name;
int
introop=1;
roop=1;
HelloClass(String
HelloClass(Stringx){
x){
name=x;
name=x;
}}
}}
public
publicvoid
voidhello(){
hello(){
System.out.println(this.name
System.out.println(this.name++":Hello
":HelloWorld");
World");
}}
public
publicclass
classHelloWorld{
HelloWorld{
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args){
args){
int
inttestnum=5;
testnum=5;
HelloClass
HelloClassdt01
dt01==new
newHelloClass("OB01");
HelloClass("OB01");
HelloClass
HelloClassdt02
dt02==new
newHelloClass("OB02");
HelloClass("OB02");
}}
}}
dt01.hello();
dt01.hello();
dt02.hello();
dt02.hello();
書く際のお約束
修飾子について
サンプルプログラムを見ると、各行の末尾に
と思います。
このように、Javaは、1文の末尾に
構造上の塊を示すために、
{}
;
;
を書きます。
を使用します。
01:
01:
03と14行目：
クラスの宣言
Data3
publicなメソッド
privateなメソッド
1.
2.
3.
3つの部分に分けられる。
クラスを書く
インスタンスを生成する
実際に使ってみる
変数の宣言
03:
03: class
class HelloClass{
HelloClass{
04:
String
04:
String name;
name;
05:
int
05:
int roop=1;
roop=1;
コンストラクタ
06:
06:
07:
HelloClass(String
x){
07:
HelloClass(String x){
08:
name=x;
08:
name=x;
メソッド
09:
}}
09:
10:
10:
11:
public
11:
public void
void hello(){
hello(){
12:
System.out.println(this.name
12:
System.out.println(this.name ++ ":Hello
":Hello World");
World");
13:
}}
13:
14:
14: }}
クラスを書く
インスタンスを生成する
実際に使ってみる
最初にclassと書き、その後にクラス名を記述します。
直後の中括弧の間に、実際の中身を書きます。
記述方法
class
class クラスの名前{
クラスの名前{
中略
中略
}}
publicな変数
privateな変数
03～14行目：
クラスの記述
import
import java.lang.String;
java.lang.String;
1.
2.
3.
public ： すべてのクラスのメソッドからアクセス可能
private：同じクラスのメソッドからのみアクセス可能
省略したら、同じパッケージ内でpublicになる
Data1
01行目：
パッケージのimport
Javaには、すでに多くのクラスが準備されている。
つまり、1から自分でわざわざ書く必要はない。
パッケージという形でまとめられている。
どのパッケージを使うのかを指定するときにimportを
使用する。
書き方：
import
import パッケージ名；
パッケージ名；
例：
クラスを書く
インスタンスを生成する
実際に使ってみる
修飾子というのが、これから出てきます。
それぞれの変数やメソッドを、どこから利用でき
るかを指定します。
がある
"クラスはここからここまで"、"メソッドはここからここ
まで" ということを示す。
囲まれているのをブロックと呼んだりします。
1.
2.
3.
04と05行目：
変数の宣言
1.
2.
3.
クラスを書く
インスタンスを生成する
実際に使ってみる
変数とは、"値を保存しておく箱"のようなものです。
入れられるものの種類が決まっています。
最初に「こういうのを入れる、こういう名前の箱を使う」と
いうことを書いておく必要があります。→宣言
記述方法
型
型
変数名,
変数名, 変数名;
変数名;
記述例：
03:
03:
14:
14:
class
class HelloClass{
HelloClass{
中略
中略
}}
記述例：
05:
05:
int
int roop=1;
roop=1;
宣言と同時に値を代入する場合
1.
2.
3.
11～13行目
メソッド
クラスを書く
インスタンスを生成する
実際に使ってみる
メソッドとは、インスタンスに対する操作のこと。
インスタンスが何をするかを記述する。
「入力を貰い、何か処理をし、出力をする」が基本。
11～13行目
メソッドの書き方
修飾子
修飾子 返値の型
返値の型 メソッド名(引数1の型
メソッド名(引数1の型 引数1){
引数1){
文;
文;
出力がある場合書く
}}
出力
メソッド
入力
0～複数個
0～1個
何か処理をする
07～09行目
コンストラクタ
1.
2.
3.
この機能を使うと、柔軟に初期値とかを設定できます。
11:
11:
12:
12:
13:
13:
クラスを書く
インスタンスを生成する
実際に使ってみる
インスタンスを生成するときに、自動的に実行される。
返値のないメソッドのように記述される。
コンストラクタの名前は、クラスの名前と同一になります。
インスタンスを生成するときに渡す引数の種類によって、
使用するコンストラクタを切り替えることができます。
コンストラクタが無い場合は、何も行われない。
07:
07:
08:
08:
09:
09:
14:
14:
17:
17:
18:
18:
20:
20:
25:
25:
26:
26:
class HelloClass{
（略）
HelloClass(String x){
name=x;
}
（略）
}
コンストラクタ
インスタンス生成時の引数は、
コンストラクタに渡される。
インスタンスが生成され
たときに実行される。
public class HelloWorld{
public static void main(String[] args){
HelloClass dt01 = new HelloClass("OB01");
（略）
}
}
出力
メソッド
public
public void
void hello(){
hello(){
System.out.println(this.name
System.out.println(this.name ++ ":Hello
":Hello World");
World");
}}
1.
クラスを書く
2. インスタンスを生成する
07～09行目：
3. 実際に使ってみる
コンストラクタの書き方
返値の無いメソッドのように書きます。
クラス名(引数1の型
クラス名(引数1の型 引数1){
引数1){
文;
文;
}}
入力の個数文だけ書く
06:
06:
07:
07:
08:
08:
09:
09:
10:
10:
HelloClass(String
HelloClass(String x){
x){
name=x;
name=x;
}}
1.
2.
3.
クラスを書く
インスタンスを生成する
実際に使ってみる
20,21行目
インスタンスの生成 その1
コンストラクタの実行：
03:
03:
クラスを書く
インスタンスを生成する
実際に使ってみる
入力の個数文だけ書く
次のように書きます。
return
return 返値;
返値;
入力
1.
2.
3.
宣言と生成を行う必要がある。
宣言の仕方： クラス名
クラス名 インスタンス名;
インスタンス名;
生成の仕方： インスタンス名
インスタンス名 == new
new クラス名();
クラス名();
例えば、クラス HelloClass のインスタンス dt01 を生成
するなら、
HelloClass
HelloClass dt01;
dt01;
dt01
dt01 == new
new HelloClass();
HelloClass();
1.
2.
3.
クラスを書く
インスタンスを生成する
実際に使ってみる
20,21行目
インスタンスの生成 その2
宣言と生成を1行で書くこともできる。
クラス名
クラス名 インスタンス名
インスタンス名 == new
new クラス名();
クラス名();
例えば、クラス HelloClass のインスタンス dt01 を生成す
るなら、
1.
2.
3.
23,24行目：
使い方
クラスを書く
インスタンスを生成する
実際に使ってみる
インスタンスのメンバにアクセスするには、
インスタンス名.メンバ名
インスタンス名.メンバ名
ドット
とする。
インスタンス dt01 の変数 roop を参照したい場合、
dt01.roop
dt01.roop
HelloClass
HelloClass dt01
dt01 == new
new HelloClass();
HelloClass();
インスタンス dt01 のメソッド hello を実行したい場合、
dt01.hello()
dt01.hello()
流れ(1)
17:
17:
18:
18:
19
19
20:
20:
21:
21:
22:
22:
23:
23:
24:
24:
25:
25:
26:
26:
流れ(2)
20行目でdt01が生成。コンストラクタでdt01の変数
nameにはOB01が代入。
同様に、21行目でdt02が生成。
public
publicclass
classHelloWorld{
HelloWorld{
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args){
args){
int
inttestnum=5;
testnum=5;
HelloClass
HelloClassdt01
dt01==new
newHelloClass("OB01");
HelloClass("OB01");
HelloClass
HelloClassdt02
dt02==new
newHelloClass("OB02");
HelloClass("OB02");
}}
}}
dt01.Hello();
dt01.Hello();
dt02.Hello();
dt02.Hello();
dt01
dt02
hello();
hello();
roop=1;
roop=1;
name="OB01";
name="OB02";
17:
17:
18:
18:
19
19
20:
20:
21:
21:
22:
22:
23:
23:
24:
24:
25:
25:
26:
26:
演習3：
内容
サンプルプログラム3を入力し、コンパイル、実行を行
います。
どのようなファイルができるか、確認していきます。
流れ：
1. ファイルをおくフォルダの作成
2. テキストエディタで HelloWorld.java を入力、作成
3. コマンドプロンプト上で、HelloWorld.javaをコンパ
イル
4. コマンドプロンプト上で、HelloWorld を実行
23行目でdt01のhelloを実行。
helloはnameの中身"OB01"と"Hello World"を出力。
同様に、24行目はdt02のhelloを実行。
public
publicclass
classHelloWorld{
HelloWorld{
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args){
args){
int
inttestnum=5;
testnum=5;
HelloClass
HelloClassdt01
dt01==new
newHelloClass("OB01");
HelloClass("OB01");
HelloClass
HelloClassdt02
dt02==new
newHelloClass("OB02");
HelloClass("OB02");
}}
}}
dt01.Hello();
dt01.Hello();
dt02.Hello();
dt02.Hello();
dt01
dt02
hello();
hello();
roop=1;
roop=1;
name="OB01";
name="OB02";
演習3：
ソースの記述、コンパイル、実行
1.
2.
HelloWorld.java というファイル名で保存します。
コマンドプロンプトで、次を入力・実行します。
javac
javac HelloWorld.java
HelloWorld.java
3.
フォルダ Java 内に、HelloWorld.class と
HelloClass.class ができたことを確認しましょう。
1つのクラス毎に1つのファイルができます。
コマンドプロンプトで、次を入力・実行します。
java
java HelloWorld
HelloWorld
利点
スタティックなメソッド
メソッドの場合、わざわざインスタンスを生成しなくても、
その機能を利用できるようになります。
変数の場合、複数のインスタンスで共通に使える変数
を利用できるようになります。
注意する点
クラスメンバとインスタンスメンバ
static なメソッドの中では、インスタンスメンバな変数に
アクセスすることはできません。
class
class Test{
Test{
static
static int
int st_data;
st_data;
int
int data;
data;
staticなメソッドtest_func02の中からは、
変数dataは利用できない。
public
public static
static void
void test_func02(){
test_func02(){
文;
文;
}}
}}
変数やメソッドには、static をつけることができます。
staticがついているものをクラスメンバ、ついていないも
のをインスタンスメンバと呼びます。
staticがついている変数やメソッドに関しては、すべての
インスタンスが、同じモノを使うようになります。
クラスメンバは、インスタンスを生成しなくても利用する
ことができます。
クラスメンバには、
クラス名.メンバ名
クラス名.メンバ名
のようにアクセスします。
直感的な図
概念とか設計図の世界
int contents;
Test
static int st_cont;
•
pushContents();
•
static cont();
Test.st_cont=10;
•
Test. cont();
直感的な図
実物（オブジェクト）の世界
static と書かれたメンバが
居ることに注目！
概念とか設計図の世界
int contents;
Test
インスタンスを生成しなくても、
アクセス可能。
クラス名.メンバ名でアクセスする。
今回は、Test.st_cont の様にする。
実物（オブジェクト）の世界
Data1 contents = 10;
static int st_cont;
st_cont;
•
pushContents();
•
pushContents();
•
static cont();
•
cont();
Data2 contents = 20;
Test.st_cont=10;
st_cont;
•
•
pushContents();
•
cont();
Test. cont();
直感的な図
概念とか設計図の世界
実物（オブジェクト）の世界
Data1 contents = 10;
int contents;
Test
static int st_cont;
•
pushContents();
•
static cont();
直感的な図
同じものを利用。
概念とか設計図の世界
int contents;
Test
実物（オブジェクト）の世界
Data1 contents = 10;
st_cont;
static int st_cont;
st_cont;
•
pushContents();
•
pushContents();
•
pushContents();
•
cont();
• static cont();
Test.st_cont=15とすれば、
Data1.st_cont も15に。
•
cont();
Data2 contents = 20;
Data2 contents = 20;
Test.st_cont=10;
st_cont;
Test.st_cont=15;
st_cont;
•
•
pushContents();
•
•
pushContents();
•
cont();
•
cont();
Test.cont();
直感的な図
概念とか設計図の世界
int contents;
Test
クラスの書き方の例
ここに値を代入！
Data1.st_count=20
実物（オブジェクト）の世界
class
class Test{
Test{
static
static int
int st_data;
st_data;
int
int data;
data;
Data1 contents = 10;
static int st_cont;
st_cont;
•
pushContents();
•
pushContents();
•
static cont();
•
cont();
•
Test.cont();
public
public static
static void
void test_func02(){
test_func02(){
System.out.println(st_data);
System.out.println(st_data);
}}
}}
public
public class
class Sample04a{
Sample04a{
public
public static
static void
void main(String[]
main(String[] args){
args){
Test.st_data=10;
Test.st_data=10;
Test.test_func02();
インスタンスを生成しなく
Test.test_func02();
}}
ても使える
｝
｝
st_cont;
•
static と書くだけです
public
public void
void test_func01(){
test_func01(){
System.out.println(data);
System.out.println(data);
}}
Data2 contents = 20;
Test.st_cont=20;
Test.cont();
pushContents();
ここに代入と同じ結果
• cont();
に！
オーバーロードって？
メソッドのオーバーロード
メソッドも、
引数のデータ型
個数
並び方
のどれかが異なっていれば、同じ名前で沢山定義する
ことができます。これをオーバーロードと言います。
異なる引数で同じ処理を行いたいとき等に便利です。
例2：
例：
public class Sample04d{
public static void main(String[] args){
calc(10,20);
calc(10.5,20.5);
}
同じクラスのメソッドは、
メソッド名だけで実行できます
引数が（整数,整数）
なので、こちらが実行
public static void calc(int data01, int data02){
System.out.println(data01*data02);
引数が（double,double）
}
なので、こちらが実行
public static void calc(double data01, double data02){
System.out.println(data01+data02);
}
}
2つ以上のコンストラクタを書くことができる。
どちらが実行されるかは、引数で判断される。
class Test{
int value;
Test(){
value=10;
}
Test(int value01){
value=value01*10;
}
}
引数が無いので、
こちらが実行される。
引数として
整数が一つ
渡されるので、
こちらが実行される。
public class Sample05{
public static void main(String[] args){
Test dt01 = new Test();
Test dt02 = new Test(100);
System.out.println(dt01.value);
System.out.println(dt02.value);
}
}
継承とは
あるクラスが存在しているとき、それを流用して、違うク
ラスを記述することができる！
int data02;
•
サブクラスの書き方
サブ
クラス
Test01 int data01;
•
スーパー
クラス
test_func01();
スーパークラス
class
class Test02
Test02 extends
extends Test01{
Test01{
int
data02;
int data02;
拡張された内容
}}
Test02
int data02;
拡張された
部分
test_func01();
class
class Test01{
Test01{
int
int data01;
data01;
void
void test_func01(){中略}
test_func01(){中略}
}}
}}
Test02
•
サブクラスの書き方例
もとのクラスを拡張（extends）する形で書きます。
直感的には、以下のような感じ。
test_func01();
もとのクラスをスーパークラス、新しくできたクラスをサ
ブクラスと呼びます。
新しくできたサブクラスは、普通のクラスと同様の方法
でインスタンスを生成し、使えます。
class
class サブクラス名
サブクラス名 extends
extends スーパークラス名
スーパークラス名 {{
拡張したい内容を書く。
拡張したい内容を書く。
Test02 int data01;
Test01 int data01;
継承
サブクラス
Test01 int data01;
int data02;
•
test_func01();
生成されたインスタンス
メソッドのオーバーライド
class
class Test01{
Test01{
int
int data01;
data01;
dt02.test_func01()のように、
void
void test_func01(){中略}
test_func01(){中略}
}}
普通にアクセス
class
class Test02
Test02 extends
extends Test01{
Test01{
int
dt02.data01のように、
int data02;
data02;
}}
普通にアクセス
public
public class
class Sample04d{
Sample04d{
public
public static
static void
void main(String[]
main(String[] args){
args){
Test02
Test02 dt02
dt02 == new
new Test02();
Test02();
以下略
以下略
dt02
サブクラスの方で、
class
class Test01{
Test01{
スーパークラスと同じ名前・引数の
int
int data01;
data01;
void
メソッドを定義した場合、
void test_func01(){中略}
test_func01(){中略}
}}
サブクラスで書いた方が有効に
class
class Test02
Test02 extends
extends Test01{
Test01{
int
int data02;
data02;
メソッドのオーバーライド
void
void test_func01(){中略}
test_func01(){中略}
}}
dt01（生成されたインスタンス） Test01
data01;
data02;
data01;
•
data02;
普通に生成
•
dt01.test_func01()として、
こちらが使われる。
test_func01();
•
test_func01();
test_func01();
こちらは使われない
アブストラクトとは
アブストラクトクラス
と
アブストラクトメソッド
アブストラクトクラス
拡張されることを前提としたクラス
書式：通常のクラスの書き方に abstract とつける。
abstract
abstract 修飾子
修飾子 class
class クラス名{
クラス名{
クラスと同じように、
クラスと同じように、
変数の宣言
変数の宣言
コンストラクタ
コンストラクタ
メソッド
メソッド
等を書く
等を書く
}}
クラスを書く際に、拡張されることを前提に、クラスを書
くことができる。
アブストラクトクラス
アブストラクトクラスは、拡張されることが前提なので、
それ自身をクラスにするインスタンスは作れない。
アブストラクトクラスの中では、拡張時にオーバーライド
されることを前提に、メソッドを書くことができる。
アブストラクトメソッド
アブストラクトメソッドは、サブクラス内でオーバーライ
ドしないと、コンパイル時にエラーが出る。
アブストラクトクラスの例
abstract class Test01{
void test01(){
System.out.println("Test 01");
}
}
class Test02 extends Test01{
void test02(){
System.out.println("Test 02");
}
}
アブストラクトクラス
Test01をスーパークラス
とするサブクラスTest02
public class Sample06a{
public static void main(String[] args){
インスタンスを生成。
Test02 dt01 = new Test02();
}
Test01 dt01 = new Test01();はできない。
}
アブストラクトメソッド
サブクラスで、オーバーライドされる前提のメソッド。
サブクラス内でオーバーライドされないと、コンパイル時
にエラーが出る。
書式：メソッドに abstract とつける。
abstract
abstract 修飾子
修飾子 class
class クラス名{
クラス名{
略
略
abstract
abstract 修飾子
修飾子 返値の型
返値の型 メソッド名(引数);
メソッド名(引数);
}}
必ずオーバーライドされるため、
実際に行う内容は、ここには書かない
アブストラクトメソッドの例
アブストラクト
クラス
abstract class Test01{
void test01(){
System.out.println("Test 01");
}
アブストラクト
abstract void test02();
}
メソッド
Test01を
スーパークラス
とする
サブクラスTest02
class Test02 extends Test01{
void test02(){
System.out.println("Test 02");
}
}
public class Sample06b{
public static void main(String[] args){
Test02 dt01 = new Test02();
}
}
必ずオーバーライド
インターフェースとは
インターフェース
クラスの書き方 その1
インターフェースの書き方
書式：
interface
interface interface名{
interface名{
記号定数の宣言
記号定数の宣言
アブストラクトメソッド
アブストラクトメソッド
このインターフェースに基づいたクラスを書くことを、
インターフェースを実装すると言います。
インターフェースを実装するには、次のように書きます。
書式：
class
class クラス名
クラス名 implements
implements interface名{
interface名{
省略
省略
}}
アブストラクトメソッドだけを宣言するための機能。
インターフェース内には、定数とアブストラクトメソッド
のみを記述できる。
インターフェースに基づいたクラスを書くことができる。
このことをインターフェースを実装するという。
データのやり取りの方法を強制するので、インター
フェースと呼ばれる。
クラスと異なり、2つのインターフェースを、1つのクラ
スに同時に実装できる。
interfaceの中では、記号定数の宣言とアブストラクト
メソッドしか書くことができません。
}}
アブストラクトメソッドは、クラス内でオーバーライドする
必要があります。
クラスの書き方 その2
2つ以上のインターフェースを同時に実装できます。
書式：
クラスを継承し、さらにインターフェース実装できます。
書式：
class
class クラス名
クラス名 implements
implements interface名,interface名{
interface名,interface名{
省略
省略
class
class クラス名
クラス名 extends
extends クラス名
クラス名 implements
implements interface名{
interface名{
省略
省略
}}
}}
, で区切って、インターフェース名を実装したいだけ繋げ
ます。
クラスの拡張とインターフェース
クラスの書き方 その3
クラスを拡張するとき、スーパークラスとして利用できる
のは、ただ1つだけ。
インターフェースは、複数を同時に利用できる。
普通の拡張
クラス その1
クラス その2
クラス
クラス
クラス
インターフェース その1
インターフェース その2
クラス
クラス
2つのスーパークラス
は持てない
インターフェースと
スーパークラスは同時
にもてる
インターフェースは
2つ同時でもOK
インターフェースの例
interface InterTest01{
double root_2 = 1.41421356;
void test01(double ddt);
}
class Test02 implements InterTest01{
public void test01(double ddt){
System.out.println(ddt*root_2);
}
}
public class Sample07a{
public static void main(String[] args){
Test02 dt01 = new Test02();
dt01.test01(100.0);
}
}
インターフェース
インターフェースを
実装したクラス
インスタンスを生成。
メソッドを実行。
© Copyright 2026 Paperzz
