public class Example {
    public String publicField = “This is a public field”;
    private String privateField = “This is a private field”;
    protected String protectedField = “This is a protected field”;
    public void publicMethod() {
        System.out.println(“This is a public method”);
    }
    private void privateMethod() {
        System.out.println(“This is a private method”);
    }
    protected void protectedMethod() {
        System.out.println(“This is a protected method”);
    }
}
public class AnotherClass {
    public static void main(String[] args) {
        Example example = new Example();
        // Accessing public members from AnotherClass is allowed
        System.out.println(example.publicField);    // Valid
        example.publicMethod();                     // Valid
        // Private members are not accessible from AnotherClass
        // The following lines would result in a compilation error
        // System.out.println(example.privateField);   // Invalid
        // example.privateMethod();                    // Invalid
        // Protected members can be accessed from AnotherClass, but only if it’s a subclass of Example
        SubclassOfExample subExample = new SubclassOfExample();
        System.out.println(subExample.protectedField);  // Valid
        subExample.protectedMethod();                   // Valid
    }
}
class SubclassOfExample extends Example {
    public void accessProtectedField() {
        System.out.println(protectedField);   // OK, because SubclassOfExample is a subclass of Example
    }
}

public class Example {
    public string publicField = “This is a public field”;
    private string privateField = “This is a private field”;
    protected string protectedField = “This is a protected field”;
    public void PublicMethod() {
        Console.WriteLine(“This is a public method”);
    }
    private void PrivateMethod() {
        Console.WriteLine(“This is a private method”);
    }
    protected void ProtectedMethod() {
        Console.WriteLine(“This is a protected method”);
    }
}
public class AnotherClass {
    public static void Main(string[] args) {
        Example example = new Example();
        // Accessing public members from AnotherClass is allowed
        Console.WriteLine(example.publicField);  // OK
        example.PublicMethod();                 // OK
        // Private members are not accessible from AnotherClass
        // The following lines would result in a compilation error
        // Console.WriteLine(example.privateField); // Error
        // example.PrivateMethod();                // Error
        // Protected members can be accessed from AnotherClass, but only if it’s a subclass of Example
        SubclassOfExample subExample = new SubclassOfExample();
        Console.WriteLine(subExample.protectedField); // OK
        subExample.ProtectedMethod();                  // OK
    }
}
public class SubclassOfExample : Example {
    public void AccessProtectedField() {
        Console.WriteLine(protectedField); // OK, because SubclassOfExample is a subclass of Example
    }
}

internal class BaseClass {
   public static int intM = 0;
} 
// An attempt to instantiate BaseClass will produce an error.
class TestAccess {
   static void Main() {
      var myBase = new BaseClass();   // Invalid
   }
}
public class BaseClass {
   internal static int intM = 0;
} 
public class TestAccess {
   static void Main() {
      var myBase = new BaseClass();   // Valid
      BaseClass.intM = 444;    // Invalid
   }
}