Java的任何事情都可以记录

1 年 ago
文, 翔
11 minutes

悄悄地在学习中，为了忘记了要自己搜索一下。

设定的数目

final データ型 定数名 = 値

把以下内容用中文本地化改写，只需要给出一个选项：

无

没有参照对象的状态
空(“”)字符串是指存在一个空字符串的参照对象，因此不是null
→ 对于原始类型，不存在null这个状态

我想要进行比较。

如果使用null的equals方法，会导致异常发生（NullPointerException）。可以使用”==”操作符。

在汉语中，空文字是

使用”isEmpty”方法会更好

传承

可以通过扩展现有的类来创建子类。
子类会继承超类的字段和方法。
要访问超类的方法，请使用 super 关键字。
要访问子类的方法，请使用 this 关键字。
超类只有一个，而子类可以有多个。

super.hoge();

覆写

在子类中实现父类的方法名、返回值和参数相匹配的方法。显式地添加“@Override”好像是个好主意。

//子クラス
@Override
void hoge(){
}

重写的方法会优先选择子类的方法。

抽象类

无法创建实例的类

abstract class TestClass {
    void test() {
        System.out.println("TEST");
    }
}
public class SampleProgram {
    public static void main(String[] args) {
        //コンパイルエラー：型 TestClass のインスタンスを生成できません
        TestClass tc = new TestClass();
    }
}

抽象方法

    • メソッド内に命令の入ってないメソッドのこと

 

    • 抽象メソッドは、抽象クラスに定義する

 

    抽象クラスを継承したサブクラスは、抽象メソッドをオーバーライドしない限り抽象クラスのまま（？？）
abstract class TestClass {
    //普通のメソッド
    void test() {
        System.out.println("TEST");
    }
    //抽象メソッド
    abstract void test2();
}

abstract class TestClass {
    //コンパイルエラー：抽象メソッドは本文を指定しません
    abstract void test() {
        System.out.println("TEST");
    }
}

如果继承了抽象类，并且将子类定义为抽象类，那么是不是意味着不需要进行覆写呢。。

abstract class TestClass {
    //普通のメソッド
    void test() {
        System.out.println("TEST");
    }
    //抽象メソッド
    abstract void test2();
}

//コンパイルエラーにならない
abstract class subClass extends TestClass {
}

//コンパイルエラー：型 subClass は継承された抽象メソッド TestClass.test2() を実装する必要があります
class subClass extends TestClass {
}

接口

    • クラスが持つべき、メソッドを定義したもの

 

    • インターフェースで定義したものは、クラスで実装する

 

    • クラスで実装するものは、インターフェースで定義したメソッドすべて。

 

    • 継承のように、１対Ｎではなく。Ｎ対Ｎの多重継承ができる。

 

    • インターフェースで定義されたメソッドは、暗黙的に「public abstract」修飾子付きとして扱われるので、実装する際は、必ず「public」修飾子を付ける。

 

    • クラスでインターフェースを実装するときは、インターフェースを「,」で区切る

 

    • メソッドだけじゃなくて、定数も定義できる

 

    • インターフェースのフィールドで定義された変数は、修飾子なしで、暗黙的に

 

    • 「public static final」付き、つまり、定数になる。

 

    インターフェースもインターフェースを継承できる。
interface testIf{
    int test();
    void test2(String msg);
}

interface testIf{
    void test2(String msg);
}
//コンパイルエラー：型 test は継承された抽象メソッド testIf.test2(String) を実装する必要があります
class test implements testIf{

}

//コンパイルエラー：testIf から継承されたメソッドの可視性を下げることはできません
class test implements testIf{
    void test2(String msg) {
        System.out.println(msg);
    }
}

// コンパイルエラーなし
class test implements testIf{
    public void test2(String msg) {
        System.out.println(msg);
    }
}

在中文中，可以这样表达：同时实现多个接口。

interface testIf1{
    void test1(String msg);
}

interface testIf2{
    int test2();
}

class test implements testIf1, testIf2{
    public void test1(String msg) {
        System.out.println(msg);
    }

    public int test2() {
        return 1;
    }
}

在接口中定义常量

interface testIf1{
    int HOGE = 1;
    public static final String HOGE2 = "定数";
}

class test implements testIf1{
    int i = testIf1.HOGE;
    //コンパイルエラー：final フィールド testIf1.HOGE には代入できません
    //testIf1.HOGE = 1;
    void testPrint() {
        System.out.println(testIf1.HOGE2);
    }
}

public class SampleProgram {
    public static void main(String[] args) {
        test t = new test();
        t.testPrint();
    }
}

接口的继承 de

interface testIf1{
    int HOGE = 1;
    public static final String HOGE2 = "定数";
    void test();
    void test2();
}
//インターフェースの継承
interface testIf2 extends testIf1{
    void test();
}

//コンパイルエラー：型 test は継承された抽象メソッド testIf1.test2() を実装する必要があります
class test implements testIf2{

    @Override
    public void test() {
        // TODO 自動生成されたメソッド・スタブ
    }
}

//コンパイルエラーなし
class test implements testIf2{

    @Override
    public void test() {
        // TODO 自動生成されたメソッド・スタブ
    }

    @Override
    public void test2() {
        // TODO 自動生成されたメソッド・スタブ        
    }
}

即使在父接口和子接口中有相同的方法定义，它不会被视为错误。尽管可能会导致混乱。

多態性

在日语中，多态性（表示有多样化的行为）这个词有这个意思。

    • スーパークラスの型の変数に、サブクラスのインスタンスを代入できる

 

    • インターフェースの型の変数に、インターフェースを実装したクラスのインスタンスを代入できる

 

    メソッドを呼び出すと、変数の型に関係なく、変数が参照するメソッドが実行される。（難しい。。）
import java.util.ArrayList;
import java.util.List;

interface TestIf{
    public abstract void run();
}

class TestAAA implements TestIf{

    String myClassName = "TestAAA";
    @Override
    public void run() {
        // TODO 自動生成されたメソッド・スタブ
        System.out.println(myClassName);
    }
}


class TestBBB implements TestIf{

    String myClassName = "TestBBB";
    @Override
    public void run() {
        // TODO 自動生成されたメソッド・スタブ
        System.out.println(myClassName);
    }
}


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

        //インターフェース型のコレクション、配列を用意
        List<TestIf> list = new ArrayList<TestIf>();
        TestIf[] array = new TestIf[2];

        //コレクションに各インスタンスを設定
        list.add(new TestAAA());
        list.add(new TestBBB());

        //配列に各インスタンスを設定
        array[0] = new TestAAA();
        array[1] = new TestBBB();

        System.out.println("コレクション");
        for(TestIf ti: list) {
            ti.run();
        }
        System.out.println("配列");
        for(int i = 0; i < array.length; i++) {
            array[i].run();
        }

    }
}

抄写/复印

数组的复制 de

array2成为array1的引用。
如果更改array2的元素，也会影响到array1。
反之亦然。

int[] array1 = {1,2,3};
int[] array2 = array1;

如果使用clone方法，可以复制值。
集合也是如此。
java
int[] array2 = array1.clone();

浅层复制，深层复制

在克隆方法中可能会出现不足的情况。
当元素不是基本类型，而是对象类型时，
对象类型并不是值，而是以引用作为元素，所以不会复制引用指向的值。这就是浅复制。
这样做会导致多个对象共享相同的值。
将引用指向的值复制过来称为深复制。
到底要复制多少取决于程序本身。

看起来很困难。。

ジェネリクス

可以通过使用”<>”符号来指定并强制数据类型。

使用泛型的模式。

只能接受字符串类型。


List<String> list = new ArrayList<String>();

不使用泛型的模式

在Eclipse上会有注意消息出现，但是可以使用。
由于不需要指定数据类型，所以除了原始类型之外，任何类型都可以传入。


List list = new ArrayList();

泛型的好处 de

    • 明示的なキャストがいらない

 

    • キャストは処理を遅くする可能性がある

 

    どんなデータが入るかわかりやすい
List list = new ArrayList();
List<String> list2 = new ArrayList<String>();

// キャストが複雑
System.out.println(((String) list.get(0)).length());
// 普通のString型と同じように使える
System.out.println(list2.get(0).length());

确实，用泛型可能会更容易一些。
不过，Eclipse很出色。

数组

数组的元素个数

配列名.length

重复各种不同的东西

最基础的

public class SampleProgram {

    public static void main(String[] args) {
        int[] box = {0,1,2,3,4,5,6,7,8,9};

        for(int i = 0; i < 10; i++) {
            if(i == 5) {
                System.out.println(i+1+":"+box[i]+"_continue");
                continue;
            }else if(i == 7) {
                System.out.println(i+1+":"+box[i]+"_break");
                break;
            }
            System.out.println(i+1+":"+box[i]);
        }
    }
}

//結果
1:0
2:1
3:2
4:3
5:4
6:5_continue
7:6
8:7_break

public class SampleProgram {

    public static void main(String[] args) {
        int[] box = {0,1,2,3,4,5,6,7,8,9};
        int i = 0;
        while(i < 10) {
            System.out.println(i+1+":"+box[i]);
            i++;
        }
    }
}

public class SampleProgram {

    public static void main(String[] args) {
        int[] box = {0,1,2,3,4,5,6,7,8,9};
        int i = 0;
        do {
            System.out.println(i+1+":"+box[i]);
            i++;
        }while(i < 10);
    }
}

久しぶりにdo~whileを見たな・・
当增加了下标时，名字的库存就会减少。。

扩展for循环

import java.util.HashSet;
import java.util.Set;

public class SampleProgram {

    public static void main(String[] args) {
        // 値の重複を許さない
        // 順序の保証もない
        Set<String> hs = new HashSet<String>();
        hs.add("白");
        hs.add("赤");
        hs.add("白");
        hs.add("緑");

        int[] array = {1,2,3,1};

        // HashSetにはgetメソッドがない
//        for(int i = 0; i < hs.size(); i++) {
//            System.out.println(hs.(i));
//        }

        // 拡張for 文
        for(String item : hs) {
            System.out.println(item);
        }

        for(int i : array) {
            System.out.println(i);
        }
    }
}

//結果
緑
赤
白
1
2
3
1

匿名函数

太难了。。

各种各样


public class TestMain {
    public static void main(String[] args) {
        List<String> cities = new ArrayList<String>();
        cities.add("京都");
        cities.add("大阪");
        cities.add("愛知");

        System.out.println("ループ１");
        for(int i = 0; i < cities.size(); i++) {
            System.out.println(cities.get(i));
        }
        System.out.println("ループ２");
        for(Iterator<String> ite = cities.iterator(); ite.hasNext();) {
            System.out.println(ite.next());
        }
        System.out.println("ループ３：拡張forループ");
        for(String city : cities) {
            System.out.println(city);
        }

        System.out.println("ループ４：");
        cities.forEach(new Consumer<String>() {
            public void accept(final String citiy) {
                System.out.println(citiy);
            }
        });

        System.out.println("ループ５：ラムダ式");
        cities.forEach((final String city) -> System.out.println(city));

        System.out.println("ループ６：ラムダ式");
        cities.forEach(System.out::println);
    }

}

地图

键值对的循环列表

import java.util.HashMap;
import java.util.Map;
public class SampleProgram {

    public static void main(String[] args) {

        Map<String, String> map = new HashMap<String, String>(){
            {
                put("001","赤");
                put("002","青");
                put("003","緑");
            }
        };

        // 値
        for(String item : map.values()) {
            System.out.println(item);
        }

        // キー
        for(String item : map.keySet()) {
            System.out.println(item);
        }
    }
}

默认编码

在使用javac进行编译时

用Sakura编辑器或者记事本随便写写源代码。

javac hoge.java

以前从未察觉，只是轻松地在Eclipse上点击按钮进行编译和运行而已。
当我尝试在DOS上手动编译之前，我没有意识到在Eclipse上创建的源代码。


//ソースコード
public class SampleProgram {
    public static void main(String[] args) {
        System.out.println("ほげ");
    }
}

//結果
C:\MyWork\>javac SampleProgram.java
SampleProgram.java:6: エラー: この文字は、エンコーディングMS932にマップできません
        System.out.println("縺ｻ縺?");
                               ^
エラー1個

C:\MyWork\>

在使用javac进行编译时，如果不指定编码，它将使用JVM（？）的默认编码进行编译。在Windows环境下，如果文件的编码是”UTF-8″，那么就会出现与Windows默认编码”MS932″不匹配的情况。

javac -encoding utf8 SampleProgram.java

如果这样做的话，就能成功编译。 (If you do it this way, you can successfully compile.)

查看默认编码的方法

import java.util.Properties;
import java.util.Enumeration;

class sampleEncoding{
  public static void main(String args[]){
    System.out.println(System.getProperty("file.encoding"));
  }
}

更改默认编码。

在Java程序中，似乎默认编码对输入输出也有影响。
当读取文件时，如果没有指定文件的编码，
就会使用默认编码。在默认编码为“utf8”的环境下，
如果要读取的文件为“euc”编码，如果不指定编码，
会导致乱码。

如果事先更改默认编码，即使不修改源代码或输入文件，也可以避免乱码问题，并能够进行编译。

REM windowsの場合
set JAVA_TOOL_OPTIONS=-Dfile.encoding=UTF8


C:\MyWork>javac SampleProgram.java
SampleProgram.java:6: エラー: この文字は、エンコーディングMS932にマップできません
        System.out.println("縺ｻ縺?");
                               ^
エラー1個

C:\MyWork>set JAVA_TOOL_OPTIONS=-Dfile.encoding=UTF8

C:\MyWork>javac SampleProgram.java
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF8

C:\MyWork>

金钱计算时不要使用float或double。

据说，当在内部转换为二进制并进行计算时，会产生误差。

听说要使用BigDecimal类。
听说要进行计算而不是转换成二进制。

import java.math.BigDecimal;

public class SampleProgram {

    public static void main(String[] args) {
        double xx = 1.0;
        double yy = 0.9;
        System.out.println(xx - yy);
        System.out.println(xx / yy);

        BigDecimal x = new BigDecimal("1.0");
        BigDecimal y = new BigDecimal("0.9");

        System.out.println(x.subtract(y));
        System.out.println(x.divide(y, 2, BigDecimal.ROUND_UP));
        System.out.println(x.divide(y, 2, BigDecimal.ROUND_DOWN));
        System.out.println(x.divide(y, 2, BigDecimal.ROUND_HALF_UP));
        System.out.println(x.divide(y, 3, BigDecimal.ROUND_HALF_DOWN));
        System.out.println(x.divide(y, 2, BigDecimal.ROUND_HALF_UP));
        System.out.println(x.divide(y, 3, BigDecimal.ROUND_HALF_DOWN));
    }

}


//結果
0.09999999999999998
1.1111111111111112
0.1
1.12
1.11
1.11
1.111
1.11
1.111

大数.ROUND_HALF_UP和大数.ROUND_HALF_DOWN有什么区别呢？
收到评论后，我重新调查了一下。
大数.ROUND_HALF_UP是四舍五入
大数.ROUND_HALF_DOWN是五舍六入
真是完全不同呢。。。

import java.math.BigDecimal;
import java.text.DecimalFormat;

public class SampleProgram {

    public static void main(String[] args) {

        DecimalFormat format = new DecimalFormat("#.#");
        BigDecimal x = new BigDecimal("10.55");



        BigDecimal xx = x.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("小数第２位で四捨五入 : " + format.format(xx));

        BigDecimal xxx = x.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("小数第２位で五捨六入 : " + format.format(xxx));

    }

}

//結果
小数第２位で四捨五入 : 10.6
小数第２位で五捨六入 : 10.5

顺便一提，如果只指定了除数，以下异常情况可能会发生……似乎是因为计算结果会变成循环小数。

System.out.println(x.divide(y));

//例外
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
    at java.math.BigDecimal.divide(BigDecimal.java:1690)
    at SampleProgram.main(SampleProgram.java:15)

在数字源上的外观

可以使用「_」进行分隔。
显示结果不会对计算产生影响。嗯…也许对于常量定义很方便？

int x = 1_000;

我想要將它賦值給不同的類型。

只能使用具有互通性的演员阵容。

int x = 12;
int y = 5;
double ans = (double)x / (double)y;

相关的事物

    • プリミティブ型同士

 

    • クラスの継承元が同じ

 

    同じインターフェースが実装されている

然而，希望将数字转换为字符。

使用String.valueOf方法
用法为，
类名.方法名

int x = 1234;
String ss = String.valueOf(x);

由于字符串类型, 因此可以使用length方法。

public class SampleProgram {

    public static void main(String[] args) {
        int x;
        x = 123 * 234;
        System.out.println(String.valueOf(x).length());
    }

}

对于类进行方法调用

    • 静的メソッド

 

    • staticメソッド

 

    クラスメソッド

這意味著對於對象（變量）調用的方法被稱為實例方法。

判断的方法是看是否存在“static”。

想把文本转换成数字。

使用包装类将原始类型转换为对象。

プリミティブ型ラッパークラスbooleanBooleancharCharacterbyteByteshortShortintIntegerlongLongfloatFloatdoubleDouble
import java.io.IOException;

public class SampleProgram {

    public static void main(String[] args) throws IOException {
       String x = "123";
       String xx = "12.45";
       int y;
       double yy;

       // String型へ、プリミティブ型は代入できない
       //y = x;

       y = Integer.valueOf(x);
       System.out.println(y);
       yy = Double.valueOf(xx);
       System.out.println(yy);
    }
}
//結果
123
12.45

总结

    • プリミティブ型同士は、キャストで対応（ex. (double)i / (double)ii）

 

    • String型→プリミティブ型は、Stringクラスのメソッドで対応

 

    プリミティブ型→String型は、ラッパークラスで対応

文件的输入输出

输入1

由于只写close()会导致”未处理的异常类型IOException”错误，所以我添加了抛出声明。(真没想到2021年还有使用Java 1.6的项目存在…)

package prototype.test.readfile;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        System.out.println("Start.......");
        // Fileオブジェクトは文字列が書き込まれているファイルを表す
        String filePath = "C:\\MyWork\\work\\eclipse-workspace\\file\\input.txt";
        File file = new File(filePath);
        BufferedReader br =null;
        try {
            // Fileオブジェクトから文字列を受け取る
            FileReader fr = new FileReader(file);
            // 受け取った文字列を蓄えておき、要求に応じて文字列を渡す
            br = new BufferedReader(fr);
            String line = null;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        } catch (IOException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        }finally {
            System.out.println("close!!");
            br.close();
        }
        System.out.println("End.........");

    }
}

//結果
Start.......
Test 1
Test 2
close!!
End.........

2输入

将输入1的tyr-catch语句转换为try-with-resources语句。

package prototype.test.readfile;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * try-with-resourcesを使ったバージョン
 * java1.7から仕様可能
 *
 */
public class Main2 {
    public static void main(String[] args) throws IOException {
        System.out.println("Start.......");
        String filePath = "C:\\MyWork\\work\\eclipse-workspace\\file\\input.txt";
        File file = new File(filePath);

        try(
            //リソースの宣言 ここで宣言した変数に対して、自動的にclose()メソッドが呼ばれる
            FileReader fr = new FileReader(file);
            BufferedReader  br = new BufferedReader(fr);
            )
        {
            String line = null;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("End.........");

    }

}

枚举 jǔ).

--Const.java
package prototype.test.Const;

public class Const {
    public static enum PEN {
        pencil("えんぴつ"),
        ballpoint_pen("ボールペン"),
        fountain_pen("万年筆");

        private String name;

        /**
         * プライベートコンストラクタ 列挙型のインスタンス生成を抑止します
         */
        private PEN(String name) {
            this.name = name;
        }

        public String getValue() {
            return this.name;
        }

    }
}
--Main2.java
package prototype.test.Const;

import prototype.test.Const.Const.PEN;

public class Main2 {

    public static void main(String[] args) {
        // TODO 自動生成されたメソッド・スタブ
        String pen = "えんぴつ";
        System.out.println("pen["+pen+"]");
        if(PEN.pencil.getValue().equals(pen)) {
            System.out.println("OK");
        }else {
            System.out.println("NG");
        }
    }

}

写条件的方式

如果

当开始学习各种语言时，就会搞不清楚如何正确使用“else if”的写法。

基本形态

if(条件１) {

}else if(条件２) {

}else {

}

比较运算符

演算子意味==等しい!=異なる>->=-<-<=-

逻辑运算符 lǐ qí)

    • AND：&&

 

    • OR：||

 

    NOT：!
「==」和「equals」

「==」判断对象（地址）是否相同，而判断值是否相同可以使用「equals」。”equals”适用于非原始类型。

基本类型和引用类型的区别在于，基本类型存储的是值，而引用类型存储的是对象的地址。

正则表达式

太难了。。

public class SampleProgram {

    public static void main(String[] args)  {

        String[] tell = {"090-1234-1234","1234-1234-1234","090-O123-1234"};
        /*
         * 3桁の数字 - 4桁の数字 - 4桁の数字
         */
        for(int i = 0; i < tell.length; i++) {
            System.out.println(tell[i]);
            if(tell[i].matches("\\d{3}-\\d{4}-\\d{4}")) {
                System.out.println("正解");
            }else {
                System.out.println("不正解");
            }
        }

    }

}

//結果
090-1234-1234
正解
1234-1234-1234
不正解
090-O123-1234
不正解

特例

基本形态

最后，”finally” 这个词用得不太多吧。。

try{

}catch(例外のクラス 変数名){

}finally{

}

将方法抛出到外部

如果在方法内部发生异常，可以将其抛到方法外，而不在同一个方法内捕获。必须在外部捕获异常。

戻り値 メソッド名(引数) throws 例外の型 {

}

有没有try-with-resources语法呢？听说是从Java 7开始的功能。现在先放着吧。通过评论学到了用法！可能很方便。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class SampleProgram {
    public static void main(String[] args) {
        String fileName1 =  "C:\\test3.txt";
        String fileName2 = "C:\\test4.txt";

        //String fileName1 = null;

        try (
                FileReader fr = new FileReader(new File(fileName1));
                BufferedReader bfr = new BufferedReader(fr);
                FileReader fr2 = new FileReader(new File(fileName2));
                BufferedReader bfr2 = new BufferedReader(fr2);

             )
        {
            String ss = null;

            while((ss = bfr.readLine()) != null) {
                System.out.println(ss + "を読み込みました");
                //throw new IOException();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}


//基本形
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class SampleProgram {

    public static void main(String[] args)  {

        try {
            File file = new File("C:\\test3.txt");
            FileReader fr = new FileReader(file);
            BufferedReader bfr = new BufferedReader(fr);
            String ss = null;

            while((ss = bfr.readLine()) != null) {
                System.out.println(ss + "を読み込みました");
            }
            bfr.close();

        }catch(IOException e) {
            e.printStackTrace();
        }
    }

}
//結果
java.io.FileNotFoundException: C:\test3.txt (指定されたファイルが見つかりません。)
    at java.io.FileInputStream.open0(Native Method)
    at java.io.FileInputStream.open(FileInputStream.java:195)
    at java.io.FileInputStream.<init>(FileInputStream.java:138)
    at java.io.FileReader.<init>(FileReader.java:72)
    at SampleProgram.main(SampleProgram.java:12)


//例外を外へ投げる
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class SampleProgram {

    public static void main(String[] args) throws IOException {

        File file = new File("C:\\test3.txt");
        FileReader fr = new FileReader(file);
        BufferedReader bfr = new BufferedReader(fr);
        String ss = null;

        while((ss = bfr.readLine()) != null) {
            System.out.println(ss + "を読み込みました");
        }
        bfr.close();

    }

}
//結果
Exception in thread "main" java.io.FileNotFoundException: C:\test3.txt (指定されたファイルが見つかりません。)
    at java.io.FileInputStream.open0(Native Method)
    at java.io.FileInputStream.open(FileInputStream.java:195)
    at java.io.FileInputStream.<init>(FileInputStream.java:138)
    at java.io.FileReader.<init>(FileReader.java:72)
    at SampleProgram.main(SampleProgram.java:11)

自己设定例外

使用现有的类。

可以通过throw语句抛出的是继承自Throwable类的实例。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class SampleProgram {

    public static void main(String[] args) throws IOException {

        try {
            File file = new File("C:\\test3.txt");
            FileReader fr = new FileReader(file);
            BufferedReader bfr = new BufferedReader(fr);
            String ss = null;

            while((ss = bfr.readLine()) != null) {
                System.out.println(ss + "を読み込みました");
            }
            bfr.close();
        }catch(IOException e) {
            IOException ee = new IOException("IOExceptionが発生！！");
            throw ee;

        }

    }

}

//結果
Exception in thread "main" java.io.IOException: IOExceptionが発生！！
    at SampleProgram.main(SampleProgram.java:21)

亲自制作

如果要创建未预料的异常，可以创建继承自Exception类的异常类。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;


class myException extends Exception{
    myException(String msg) {
        super(msg);
    }

}

public class SampleProgram {

    public static void main(String[] args) throws Exception {

        try {
            File file = new File("C:\\test3.txt");
            FileReader fr = new FileReader(file);
            BufferedReader bfr = new BufferedReader(fr);
            String ss = null;

            while((ss = bfr.readLine()) != null) {
                System.out.println(ss + "を読み込みました");
            }
            bfr.close();
        }catch(Exception e) {
            e.printStackTrace();
            throw new myException("thorwしました");

        }

    }

}

// 結果
java.io.FileNotFoundException: C:\test3.txt (指定されたファイルが見つかりません。)
    at java.io.FileInputStream.open0(Native Method)
    at java.io.FileInputStream.open(FileInputStream.java:195)
    at java.io.FileInputStream.<init>(FileInputStream.java:138)
    at java.io.FileReader.<init>(FileReader.java:72)
    at SampleProgram.main(SampleProgram.java:19)
Exception in thread "main" myException: thorwしました
    at SampleProgram.main(SampleProgram.java:29)

构造函数

基本的 de)

アクセス修飾子 クラス名 (引数型 引数) {
// なにか処理
}

如果存在继承关系

构造函数不被继承。

//親クラス
class p{
    p(){
        System.out.println("親のコンストラクタ１");
    }
    p(int x){
        System.out.println("親のコンストラクタ２");
    }
}
//子クラス
class c extends p{

}

public class SampleProgram {
    public static void main(String[] args) throws Exception {
        c cc = new c(10); 
        c cc = new c();
    }
}

c cc = new c(10);

如果是这样的话，
编译错误：构造函数c(int)未定义

c cc = new c();

因为子类没有声明任何内容，所以在表面上看起来继承了父类的无参数构造函数，但实际上是编译器自动添加了默认构造函数。

在代码上虽然看不出来，但似乎是这样的，似乎调用了父类的构造函数。

class c extends p{
  c(){
    super();
  }
}

亲子是一对吗??

我明确地为子类添加了构造函数，但不知何故父类的构造函数也被调用了。

class p{
    p(){
        System.out.println("親のコンストラクタ１");
    }
    p(int x){
        System.out.println("親のコンストラクタ２");
    }
}

class c extends p{
    c(){
        System.out.println("子のコンストラクタ１");
    }
}

public class SampleProgram {

    public static void main(String[] args) throws Exception {

        c cc = new c();

    }

}

// 結果
親のコンストラクタ１
子のコンストラクタ１

最終的に子类实例被创建时，当然会执行子类的构造函数。但似乎在此之前会自动调用父类的无参数构造函数，这在源代码中无法看到，但据说是这样的。

class c extends p{
    c(){
        super();★コンパイラによって勝手に付けられる
        System.out.println("子のコンストラクタ１");
    }
}

嗯嗯。。。不知道的话可能会陷入困境啊。。

其他

代码片段

一种可以用背诵或复制粘贴流用的句法构造。

我想尽量减少System.out.println的使用。


import static java.lang.System.*;

public class SampleProgram{
    public static void main(String[] args) {
        out.println("hoge");
    }
}

有用的链接

ひしだま的技术备忘录页
→Java

✖
广告
将在 10 秒后关闭
bannerAds