Artikel ini menjelaskan implementasi Java untuk mendefinisikan fungsi bahasa sederhana berdasarkan pola interpreter. Bagikan untuk referensi Anda, sebagai berikut:
Definisi pola
Pola juru bahasa: Ini adalah untuk memberikan representasi tata bahasa dari suatu bahasa dan mendefinisikan seorang interpreter untuk menafsirkan kalimat dalam bahasa tersebut. Pola penerjemah menjelaskan cara menafsirkan pernyataan ini menggunakan desain pola setelah tata bahasa sederhana.
Contoh mode kedua
1 analisis pola
Kami merancang bahasa untuk menggambarkan pola ini sendiri
(1) Bahasa sensitif case (2) bahasa dimulai dengan program dan berakhir dengan akhir (3) println berarti mencetak garis dan memecahnya (4) digunakan untuk ... dari ... ke ... end berarti loop
Konten bahasa contoh adalah sebagai berikut:
Program Println Mulai ... Untuk I dari 90 hingga 100 Println I End Println End ... End
Arti dari kalimat ini adalah: Cetak pertama kali istirahat dengan "Start ...", lalu bersepeda melalui garis istirahat dengan "90", "91", ... "100", dan akhirnya mencetak garis istirahat dengan "End ...".
2 Bahasa ini menjelaskan struktur pohon
3 Diagram Aktivitas Interpreter Bahasa
4 Contoh Kode
4.1 Buat Lingkungan Konteks - Konteks
package com.demo.interpreter.context;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.StringTokenizer;/** * Context environment* * @author * */public class Context { // The text content to be parsed private final StringTokenizer stringTokenizer; // Perintah Private String saat ini saat ini; // Digunakan untuk menyimpan konten informasi yang dinamis konten privat peta akhir <string, object> peta = new HashMap <String, Object> (); / ** * Konstruktor Mengatur Parsing Konten * * @param Text */ Public Context (String Text) {// Gunakan spasi untuk memisahkan teks yang akan diuraikan this.stringTokenizer = new stringTokenizer (teks); } / *** Parsing text* / public string next () {if (this.stringTokenizer.hasmoretokens ()) {currentToken = this.stringTokenizer.nextToken (); } else {currentToken = null; } return CurrentToken; } / ** * Tentukan apakah perintah itu benar * * @param perintah * @return * / public boolean setara dengan command (perintah string) {if (command == null ||! Command.equals (this.currenttoken)) {return false; } return true; } / ** * Dapatkan konten perintah saat ini * * @return * / string publik getCurrentToken () {return this.currentToken; } / ** * Dapatkan konten node * * @return * / public string gettokencontent (string text) {string str = text; if (str! = null) {// Ganti konten yang berubah secara dinamis di peta dan kembalikan iterator <string> // ganti konten yang berubah secara dinamis di peta dan kembalikan iterator <string> iterator = this.map.keyset (). iterator (); while (iterator.hasnext ()) {string key = iterator.next (); Objek obj = map.get (key); str = str.replaceall (kunci, obj.tostring ()); }} return str; } public void put (tombol string, nilai objek) {this.map.put (key, value); } public void clear (tombol string) {this.map.remove (key); }}4.2 Antarmuka Ekspresi - Iexpressions
Paket com.demo.interpreter.express; import com.demo.interpreter.context.context;/** * * Antarmuka ekspresi * * @author * */antarmuka publik IExpressions {/** * parsing * * @param konteks * public void parse (konteks konteks); / ** * metode eksekusi * * @param konteks */ public void interpret ();}4.3 Ekspresi Utama - ProgramExpression
Paket com.demo.interpreter.express; import com.demo.interpreter.context.context;/** * Ekspresi program * * @author * */kelas publik Programexpression mengimplementasikan iExpressions {// konteks konteks konteks akhir pribadi; // perintah saat ini Perintah string statis final swasta = "program"; // Simpan ekspresi ekspresi pribadi ekspresi pribadi; / ** * Konstruktor meneruskan konten yang akan diuraikan ke * * * @param Text */ Public ProgrookExpression (Teks String) {this.context = Konteks baru (teks); this.parse (this.context); } @Override public void parse (konteks konteks) {// Dapatkan node perintah pertama this.context.next (); } / *** Metode Penjelasan Implementasi* / @Override public void interpret () {// Tentukan apakah itu dimulai dengan program jika (! This.context.equalsWithCommand (command)) {System.out.println ("The '" + Command + "' dikecualikan untuk memulai!"); } else {// mulai this.context.next () dengan program; this.expressions = new ListExpression (); this.expressions.parse (this.context); // Ekspresi ListExpression mulai mem -parsing this.expressions.interpret (); }}}4.4 Daftar Ekspresi - ListExpression
Paket com.demo.interpreter.express; import java.util.arraylist; import java.util.iterator; import com.demo.interpreter.context.context;/** * Daftar ekspresi * * @author * */Public Class ListExpression mengimplementasikan iExpressions {Private Context Context; Private Final ArrayList <Iexpressions> Daftar = ArrayList baru <Iexpressions> (); / ** * Konstruktor melewati konteks yang harus diuraikan ke dalam * * @param Context */ public void parse (konteks konteks) {this.context = konteks; // Dalam ekspresi parsing ListExpression, loop untuk menginterpretasikan setiap kata dalam pernyataan sampai ekspresi Terminator atau pengecualian keluar saat (true) {if (this.context.getCurrentToken () == null) {// Dapatkan node saat ini. Jika null, itu berarti bahwa ekspresi akhir hilang System.out.println ("Kesalahan: Expersion hilang 'akhir'!"); merusak; } else if (this.context.equalsWithCommand ("end")) {this.context.next (); // Parsing biasanya berakhir istirahat; } else {// Buat ekspresi Perintah IExpressions Expressions = CommandExpersion baru (this.context); // tambahkan ke list.add (ekspresi); }}} / *** Menerapkan metode penjelasan* / @Override public void interpret () {// loop Penjelasan setiap ekspresi dalam daftar daftar untuk mengeksekusi iterator <iexpressions> iterator = list.iterator (); while (iterator.hasnext ()) {(iterator.next ()). Interpret (); }}}4.5 Perintah Ekspresi - CommandExpersion
Paket com.demo.interpreter.express; import com.demo.interpreter.context.context;/** * Perintah Ekspresi * * @author * */kelas publik CommandExpersion mengimplementasikan iExpressions {konteks konteks akhir pribadi; Ekspresi Privat IExpressions; / ** * Metode Konstruksi melewati konteks yang harus diuraikan ke dalam * * @param Context */ Public CommandExpersion (konteks konteks) {this.context = konteks; this.parse (this.context); } public void parse (konteks konteks) {// menilai kategori perintah saat ini, hanya membedakan untuk dan perintah asli jika (this.context.equalsWithCommand ("for")) {// buat untuk ekspresi untuk penguraian ekspresi = forexpression baru (this.context); } else {// Buat ekspresi perintah asli untuk ekspresi parsing konten = primitive expression baru (this.context); }} / *** Parsing konten* / @override void interpret () {// parsing konten this.expressions.interpret (); }}4.6 Ekspresi Loop - Forexpression
Paket com.demo.interpreter.express; import com.demo.interpreter.context.context;/** * untuk ekspresi * * @author * */kelas publik forexpression mengimplementasikan iexpressions {konteks konteks akhir pribadi; // Simpan variabel string Nilai Kunci Indeks saat ini; // Simpan posisi mulai dari loop private int start_index; // Simpan posisi akhir dari loop private int end_index; Ekspresi Privat IExpressions; / ** * Konstruktor melewati konteks yang harus diuraikan ke dalam * * @param Context */ Public Forexpression (konteks konteks) {this.context = konteks; this.parse (this.context); } / *** Ekspresi parsing* / @Override public void parse (konteks konteks) {// Pertama dapatkan node saat ini this.context.next (); while (true) {// menilai node if (this.context.equalsWithCommand ("from")) {// Atur string konten indeks start nextstr = this.context.next (); coba {this.start_index = integer.parseint (nextstr); } catch (Exception e) {System.out .println ("Kesalahan: Setelah 'dari' Ekspresi ada kesalahan! Silakan periksa format ekspresi sudah benar!"); merusak; } // Dapatkan node berikutnya this.context.next (); } else if (this.context.equalsWithCommand ("to")) {// atur string konten indeks akhir nextstr = this.context.next (); coba {this.end_index = integer.parseint (nextstr); } catch (Exception e) {System.out .println ("Kesalahan: Setelah 'untuk' Ekspresi ada kesalahan! Silakan periksa format ekspresi sudah benar!"); } this.context.next (); merusak; } else {// atur konten variabel indeks saat ini if (this.variable == null) {this.variable = this.context.getCurrentToken (); } // Dapatkan node berikutnya this.context.next (); }} // Buat Ekspresi Daftar ini. Expressions = new ListExpression (); this.expressions.parse (this.context); } / *** Menerapkan metode penjelasan* / @Override public void interpret () {// Buat ekspresi perintah untuk (int x = this.start_index; x <= this.end_index; x ++) {// atur konten variabel this.context.put ("" ini.variable, x); // jalankan metode penjelasan this.expressions.interpret (); } // Hapus konten variabel sementara yang digunakan this.context.clear ("" + this.variable); }}4.7 Ekspresi Dasar - Primitive Expression
Paket com.demo.interpreter.express; import com.demo.interpreter.context.context;/** * Ekspresi paling dasar * * @author * */kelas publik Primitive Expression mengimplementasikan iExpressions {konteks konteks privat; // Nama Node Private String TokenName; // Konten Teks Teks string pribadi; / ** * Konstruktor melewati konteks yang harus diuraikan ke dalam * * @param Context */ Public Primitive Expression (konteks konteks) {this.parse (konteks); } @Override public void parse (konteks konteks) {this.context = konteks; this.tokenName = this.context.getCurrentToken (); this.context.next (); if ("println" .Equals (this.tokenName)) {this.text = this.context.getCurrentToken (); this.context.next (); }} / *** Metode Penjelasan Implementasi* / @Override public void interpret () {// Pertama dapatkan konten node saat ini jika ("println" .equals (TokenName)) {// dapatkan informasi konten // cetak konten System.out.println (this.context.gettokenContent (this.text); }}}4.8 Biarkan penerjemah bahasa mulai bekerja - klien
package com.demo.interpreter;import com.demo.interpreter.express.IExpressions;import com.demo.interpreter.express.ProgramExpression;/** * Main application* * @author * */public class Client { /** * @param args */ public static void main(String[] args) { // myida language statement String str = "PROGRAM PRINTLN start... FOR Saya dari 90 hingga 100 println i end println end ... end "; System.out.println ("str:" + str); // Buat Ekspresi Program IExpressions Expressions = New ProgrookExpression (STR); // jelaskan eksekusi ekspresi.interpret (); }}5 Hasil berjalan
str: Program println start ... untuk saya dari 90 hingga 100 println i end println end ... end
Awal...
90
91
92
93
94
95
96
97
98
99
100
akhir...
Tiga prinsip desain
1 prinsip "dekat-dekat"
2 Prinsip Perubahan Tertutup
Empat kesempatan penggunaan
(1) Jenis masalah tertentu terjadi pada frekuensi tinggi, dan aturan bisnis sering berubah, dan situasi serupa terjadi berulang kali.
(2) Aturan bisnis tidak terlalu rumit dan rumit, dan lebih mudah untuk abstrak aturan tata bahasa.
(3) Efisiensi bukanlah faktor utama yang dipertimbangkan dalam sistem perangkat lunak.
Lima Diagram Kelas Statis Mode Interpreter
Untuk lebih banyak konten terkait Java, pembaca yang tertarik dengan situs ini dapat melihat topik: "Pendahuluan dan Tutorial Lanjutan tentang Pemrograman Berorientasi Objek Java", "Tutorial tentang Struktur Data Java dan Algorithma", "Ringkasan Keterampilan Operasi Java Java", "Ringkasan Operasi Java File dan Keterampilan Operasi Direktori" dan Ringkasan Java Operasi Java "," Ringkasan Operasi Java Keterampilan Operasi Direktori "dan" Ringkasan Java Ringkasan JAVA "
Saya harap artikel ini akan membantu pemrograman Java semua orang.