diff --git a/src/evaluator/mod.rs b/src/evaluator/mod.rs
index 6fcaf6e..e6908cf 100644
--- a/src/evaluator/mod.rs
+++ b/src/evaluator/mod.rs
@@ -86,10 +86,9 @@ pub fn eval(node: Node, env: &mut Environment) -> anyhow::Result<Object> {
 
                 apply_function(function, args)
             }
-            Expression::StringLiteral(string_literal) => Ok(StringObj {
-                value: string_literal.value.clone(),
+            Expression::StringLiteral(string_literal) => {
+                Ok(StringObj::new(string_literal.value.clone()).into())
             }
-            .into()),
             Expression::ArrayLiteral(array) => {
                 let elements = eval_expressions(array.elements().clone(), env)?;
 
@@ -254,23 +253,20 @@ fn eval_string_infix_expression(
 ) -> anyhow::Result<Object> {
     match operator.as_str() {
         "+" => {
-            let left_val = left.value;
-            let right_val = right.value;
+            let left_val = left.value();
+            let right_val = right.value();
 
-            Ok(StringObj {
-                value: format!("{left_val}{right_val}"),
-            }
-            .into())
+            Ok(StringObj::new(format!("{left_val}{right_val}")).into())
         }
         "==" => {
-            let left_val = left.value;
-            let right_val = right.value;
+            let left_val = left.value();
+            let right_val = right.value();
 
             Ok(Boolean::new(left_val == right_val).into())
         }
         "!=" => {
-            let left_val = left.value;
-            let right_val = right.value;
+            let left_val = left.value();
+            let right_val = right.value();
 
             Ok(Boolean::new(left_val != right_val).into())
         }
diff --git a/src/evaluator/tests.rs b/src/evaluator/tests.rs
index 5844969..bd4d2f0 100644
--- a/src/evaluator/tests.rs
+++ b/src/evaluator/tests.rs
@@ -612,8 +612,8 @@ fn test_string_literal() -> anyhow::Result<()> {
     let str_lit = StringObj::try_from(evaluated)?;
     println!("test string literal = {:?}", str_lit);
 
-    if str_lit.value != "Hello World!" {
-        eprintln!("String has wrong value. got = {}", str_lit.value);
+    if str_lit.value() != "Hello World!" {
+        eprintln!("String has wrong value. got = {}", str_lit.value());
     }
     Ok(())
 }
@@ -624,10 +624,10 @@ fn test_string_concatenation() -> anyhow::Result<()> {
     let evaluated = test_eval(input.to_string())?;
     let str_lit = StringObj::try_from(evaluated)?;
 
-    if str_lit.value != "Hello World!" {
+    if str_lit.value() != "Hello World!" {
         return Err(anyhow::anyhow!(format!(
             "String has wrong value. got = {}",
-            str_lit.value
+            str_lit.value()
         )));
     }
 
@@ -860,24 +860,9 @@ let two = "two";
     let result = Hash::try_from(evaluated)?;
 
     let mut expected = BTreeMap::<Object, i64>::new();
-    expected.insert(
-        Object::String(StringObj {
-            value: "one".to_string(),
-        }),
-        1,
-    );
-    expected.insert(
-        Object::String(StringObj {
-            value: "two".to_string(),
-        }),
-        2,
-    );
-    expected.insert(
-        Object::String(StringObj {
-            value: "three".to_string(),
-        }),
-        3,
-    );
+    expected.insert(Object::String(StringObj::new("one".to_string())), 1);
+    expected.insert(Object::String(StringObj::new("two".to_string())), 2);
+    expected.insert(Object::String(StringObj::new("three".to_string())), 3);
     expected.insert(Object::Integer(Integer { value: 4 }), 4);
     expected.insert(Object::Boolean(*TRUE), 5);
     expected.insert(Object::Boolean(*FALSE), 6);
diff --git a/src/object/built_in_function.rs b/src/object/built_in_function.rs
index ba62fe9..a63b660 100644
--- a/src/object/built_in_function.rs
+++ b/src/object/built_in_function.rs
@@ -38,7 +38,7 @@ pub fn process_len(args: Vec<Object>) -> anyhow::Result<Object> {
 
     match args[0].clone() {
         Object::String(string_obj) => Ok(Integer {
-            value: string_obj.value.len() as i64,
+            value: string_obj.value().len() as i64,
         }
         .into()),
         Object::Array(array) => Ok(Integer {
diff --git a/src/object/string.rs b/src/object/string.rs
index a40c416..e011361 100644
--- a/src/object/string.rs
+++ b/src/object/string.rs
@@ -5,7 +5,17 @@ use std::any::Any;
 use std::fmt::{Display, Formatter};
 #[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord, Hash)]
 pub struct StringObj {
-    pub value: String,
+    value: String,
+}
+
+impl StringObj {
+    pub fn new(value: String) -> Self {
+        Self { value }
+    }
+
+    pub fn value(&self) -> &String {
+        &self.value
+    }
 }
 
 impl Display for StringObj {
diff --git a/src/parser/tests.rs b/src/parser/tests.rs
index 96a5f07..37445ef 100644
--- a/src/parser/tests.rs
+++ b/src/parser/tests.rs
@@ -1267,13 +1267,9 @@ fn test_parsing_hash_literals_with_expressions() -> anyhow::Result<()> {
 }
 
 fn test_hash_map_use() {
-    let name1 = StringObj {
-        value: "name".to_string(),
-    };
+    let name1 = StringObj::new("name".to_string());
 
-    let monkey = StringObj {
-        value: "Monkey".to_string(),
-    };
+    let monkey = StringObj::new("Monkey".to_string());
 
     let mut pairs = BTreeMap::<Object, Object>::new();
     pairs.insert(Object::String(name1.clone()), Object::String(monkey));
@@ -1287,9 +1283,7 @@ fn test_hash_map_use() {
 
     println!("pairs[name1] = {:?}", pairs.get(&Object::String(name1)));
 
-    let name2 = StringObj {
-        value: "name".to_string(),
-    };
+    let name2 = StringObj::new("name".to_string());
 
     println!("pairs[name2] = {:?}", pairs.get(&Object::String(name2)));
 }