javaクラスの初歩的な質問

Question

下記の様なクラスがあった場合、javaならではの(?)スマートな書き方ってあるのでしょうか。
funcPre関数の重複を簡略化できるのかなと言う質問になります。

class Sample{

    public void funcA(int n){
        funcPre();
        //処理
    }

    public void funcB(int n){
        funcPre();
        //処理
    }

    public void funcC(int n, int m){
        funcPre();
        //処理
    }

    public void funcD(int n){
        //処理
    }

    //前処理
    private void funcPre(){
        //処理
    }
}

追記
多くのご回答有難うございました。
勉強になります。

記述が重複する部分をprivate関数に置き換えていると、今度は関連性のないprivate関数が増えていって、その部分が読みにくくなると思って、質問させて頂きました。

Comments

[m.ts10806]

そうしたい目的を具体的に記載いただけると助かります。

[coco_bauer]

funcPre関数で処理されるコードは、funcPre関数の定義の中にだけ存在するので重複(同じ処理をするコードが複数の関数の中に出現)はありません。その意味でSlimなコードになっています。

[swordone]

構成を考え直すことも視野に入れるべきでは？具体的にどのような処理になるのでしょうか？

Answer 1

もっとコードが具体的になれば違った回答もあるかもしれませんが、質問文にあるコードで十分簡潔だと考えてよいです。

記述が重複する部分をprivate関数に置き換えていると、今度は関連性のないprivate関数が増えていって、その部分が読みにくくなると思って、質問させて頂きました。

private メソッドが互いに関連性がない(=独立している)方がよりよいコードと言えます。
public メソッドから利用する場合に private メソッドの呼び出し順やフィールドの状態に注意しなければならないとすると、より悪い状況におちいっています。

private メソッドが単純に多い場合は別のクラス(=責務)へと切り出せないか検討するとよいでしょう。

Comments

[momon-ga]

「別のクラス(=責務)へと切り出せないか検討」の雰囲気的を感じます

Answer 2

public abstract class Sample {
    
    private void preFunc(){
        //処理
    }

    protected abstract void func();

    public void do() {
        preFunc();
        func();
    }
}

class SampleA extends Sample {
    private int n;

    public SampleA(int n) {
        this.n = n;
    }

    @Override
    protected void func() {
        //処理
    }   
}

class SampleB extends Sample {
    private int n;

    public SampleB(int n) {
        this.n = n;
    }

    @Override
    protected void func() {
        //処理
    }   
}

class SampleC extends Sample {
    private int n;
    private int m;

    public SampleC(int n, int m) {
        this.n = n;
        this.m = m;
    }

    @Override
    protected void func() {
        //処理
    }   
}

class SampleD extends Sample {
    private int n;

    public SampleD(int n) {
        this.n = n;
    }

    @Override
    protected void func() {
        //処理
    }

    @Override
    public void do() {
        func();
    }
}

public class Main {
    public static void main(String[] args) {
        Sample sampleA = new SampleA(1);
        sampleA.do();

        Sample sampleB = new SampleB(1);
        sampleB.do();

        Sample sampleC = new SampleC(1,2);
        sampleC.do();

        Sample sampleD = new SampleD(1);
        sampleD.do();
    }
}

す、すまーと

Answer 3

目的に沿ったものではないかもしれませんがコンストラクタで呼ぶのはどうでしょうか。

class Sample{

    public Sample(){
        funcPre();
    }

    public void funcA(int n){
        //処理
    }

    public void funcB(int n){
        //処理
    }

    public void funcC(int n, int m){
        //処理
    }

    public void funcD(int n){
        //処理
    }

    //前処理
    private void funcPre(){
        //処理
    }
}

funcD()を使う場合にもfuncPre()が呼び出されてしまうという点が許容できるのであれば ですが。。。

Answer 4

よくわかりませんが、たとえばこういうのですか (未検証)。

class Sample {
    class Action {
        public void exec() {
            funcPre();
            doExec();
        }
        protected void funcPre(){
            //処理 
        }
        abstract public void doExec();

    }
    class ActionA extends Action {
        public void doExec() {
             // 処理
        };
        public setArgs(int n) {
             this.n = n;
             return this;
        }
    }

    public void funcA(int n){
        return new ActionA().setArgs(n).exec();
    }

    public void funcB(int n){
        return new ActionB().setArgs(n).exec();
    }

    public void funcC(int n, int m){
        return new ActionC().setArgs(n, m).exec();
    }

    public void funcD(int n){
        //処理
    }
}

Comments

[uer03108]

有難うございました。
こういうのです。
クラスを書けばよいのですね。
助かりました。

Answer 5

Javaならでは…
Javaの標準機能だけでは無理なのですが、スマートな書き方であれば、AspectJ5によるアノテーション記法でしょうか。

以下のサンプルコードを動かすにはaspectjrtとaspectjweaverのライブラリが必要なので、少し難しいです。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

// @Aspectを書いたクラスはAspectJのコンパイル対象クラスとなり、@Beforeなどが使えるようになる
@Aspect
public class Sample {

	public void funcA(int n) {
		//処理
		System.out.println("funcA " + n);
	}

	public void funcB(int n) {
		//処理
		System.out.println("funcB " + n);
	}

	public void funcC(int n, int m) {
		//処理
		System.out.println("funcC " + n + " " + m);
	}

	public void funcD(int n) {
		//処理
		System.out.println("funcD " + n);
	}

	// @Beforeの中に条件を書くと、条件に当てはまるメソッドの処理の前に呼び出してくれる
	// callは「そのメソッドを呼び出したとき」という条件
	// 条件の書き方はAspectJの仕様を参照してください
	// 以下の条件の場合、funcA、またはfuncB、またはfuncCのときだけ実行される
	@Before("call(void funcA(int))"
			+ " || call(void funcB(int))"
			+ " || call(void funcC(int, int))")
	public void funcPre(JoinPoint joinPoint) {
		// JoinPointは呼び出し元などの情報が入っている

		System.out.println("funcPre");
		// このメソッド内でthisと書いても、funcAを呼んでいるインスタンスとは別物なので注意
		// 以下のように呼び出し元インスタンスはgetTargetで得る
		// Sample sample = (Sample) joinPoint.getTarget();
	}

	public static void main(String[] args) {
		Sample m = new Sample();
		m.funcA(0);
		m.funcB(1);
		m.funcC(2, 3);
		m.funcD(4);
	}
}

Mavenを使えばAspectJを使ったコードを簡単にビルドできます。mavenを利用した場合のpom.xmlの参考です。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>example</groupId>
	<artifactId>aspectj</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>jar</packaging>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		
		<aspectj-maven-plugin.version>1.10</aspectj-maven-plugin.version>
		<aspectj.version>1.8.10</aspectj.version>
	</properties>


	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.5.1</version>
				<configuration>
					<source>${maven.compiler.source}</source>
					<target>${maven.compiler.target}</target>		
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>aspectj-maven-plugin</artifactId>
				<version>${aspectj-maven-plugin.version}</version>
				<configuration>
					<complianceLevel>${maven.compiler.source}</complianceLevel>
					<source>${maven.compiler.source}</source>
					<target>${maven.compiler.target}</target>
				</configuration>
				<executions>
					<execution>
						<phase>process-sources</phase>
						<goals>
							<goal>compile</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${aspectj.version}</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${aspectj.version}</version>
		</dependency>
	</dependencies>
	
</project>

Comments

[uer03108]

回答有難うございました。
便利なものがあるんですね。
これは@Beforeの関数に戻り値も設定できるのでしょうか。
グローバル変数を使用するとか？？

[masaya_ohashi]

えっと、funcPreでなにか結果を返したいということでしょうか？

[uer03108]

はい。
List<Object> funcPre( )
などですが。

・前処理の値を取得
・関数内で処理（関数によって異なる）
・処理結果を後処理

といった関数を簡潔に書く方法を考えておりました。

前処理と後処理をprivate関数にしています。

private関数がゴチャゴチャ・・・と言った感じです。
複数ファイルに分けた方が良いかもしれません。

[uer03108]

重ね重ね有難うございます。

[masaya_ohashi]

一時変数を受け取らなければならない以上、省略することはできないかと思います…メンバ変数に一時的にキープしておくことは可能ですが、スレッドセーフなどを気にする必要が出てきます。とりあえず、メンバ変数に一時的に記憶する場合の処理を追記します。

[masaya_ohashi]

と思ったのですが、まず具体的にやりたいことをコードにして例示してもらえませんか。