csharp publicとは？意味・使い方・privateとの違いを初心者向けに解説

はじめに

C#を学び始めると、クラスやメソッドの前に public というキーワードが付いているコードをよく見かけます。

C#
public class Person
{
    public string Name { get; set; }

    public void SayHello()
    {
        Console.WriteLine("こんにちは");
    }
}

この public は、C#における「アクセス修飾子」の一つです。簡単にいうと、「そのクラスやメソッド、プロパティをどこから使えるようにするか」を決めるためのキーワードです。

csharp public について理解することは、C#のクラス設計やオブジェクト指向プログラミングを学ぶうえでとても重要です。特に、public と private の違いを理解できるようになると、「外部から使ってよい処理」と「クラスの内部だけで使う処理」を分けて考えられるようになります。

この記事では、C#の public の意味、基本的な使い方、private との違い、実際のサンプルコード、Unityでの使い方、初心者がつまずきやすいポイントまでわかりやすく解説します。

1. csharp publicとは？C#における基本的な意味

C#の public は、クラス、メソッド、プロパティ、フィールドなどに付けるアクセス修飾子です。アクセス修飾子とは、「どこからアクセスできるか」を指定するためのキーワードです。

public が付いているものは、基本的に外部のコードから利用できます。

たとえば、次のようなクラスがあるとします。

C#
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

この場合、Calculator クラスも Add メソッドも public なので、別のクラスから次のように呼び出せます。

C#
Calculator calculator = new Calculator();
int result = calculator.Add(3, 5);

Console.WriteLine(result);

実行結果は次のようになります。

C#
8

このように、public は「外部から使えるようにする」という役割を持っています。

1-1. publicは「どこからでもアクセスできる」ことを表すアクセス修飾子

public は、日本語にすると「公開された」「公的な」という意味です。C#では、public を付けたメンバーは、他のクラスや別のファイルからもアクセスできるようになります。

たとえば、次の Name プロパティは public です。

C#
public class User
{
    public string Name { get; set; }
}

この場合、別のクラスから次のように Name にアクセスできます。

C#
User user = new User();
user.Name = "田中";

Console.WriteLine(user.Name);

Name が public であるため、クラスの外側から値を設定したり取得したりできます。

一方で、private にすると外部からはアクセスできません。

C#
public class User
{
    private string name;
}

この場合、次のようなコードはエラーになります。

C#
User user = new User();
user.name = "田中";

private のメンバーは、そのクラスの内部からしか使えないためです。

1-2. C#でpublicが使われる主な場面

C#で public がよく使われる場面は、主に次のようなものです。

たとえば、外部からインスタンスを作る必要があるクラスでは、クラスやコンストラクターを public にします。

C#
public class Product
{
    public Product()
    {
        Console.WriteLine("商品を作成しました");
    }
}

また、外部から呼び出したい処理には public メソッドを使います。

C#
public void Display()
{
    Console.WriteLine("商品情報を表示します");
}

1-3. 初心者がまず理解すべきpublicの役割

初心者が最初に理解すべきことは、public は「外から使ってもよいもの」に付けるということです。

たとえば、銀行口座を表すクラスを考えてみます。

C#
public class BankAccount
{
    private int balance;

    public void Deposit(int amount)
    {
        balance += amount;
    }

    public int GetBalance()
    {
        return balance;
    }
}

このコードでは、残高を表す balance は private です。外部から直接変更されると危険だからです。

一方で、お金を預ける Deposit メソッドや残高を取得する GetBalance メソッドは public です。外部から安全に使ってもよい操作だからです。

C#
BankAccount account = new BankAccount();
account.Deposit(1000);

Console.WriteLine(account.GetBalance());

このように、public は「クラスの外側に公開する入口」と考えると理解しやすいです。

1-4. publicを使うと何ができるようになるのか

public を使うと、クラスの外側からその要素を利用できるようになります。

たとえば、次のようなことが可能になります。

外部からクラスを作成できます。

C#
User user = new User();

外部からメソッドを呼び出せます。

C#
user.Login();

外部からプロパティに値を設定できます。

C#
user.Name = "佐藤";

外部からプロパティの値を取得できます。

C#
Console.WriteLine(user.Name);

つまり、public は「他のコードに対して公開するための設定」です。

ただし、何でも public にすればよいわけではありません。外部から自由にアクセスできるということは、意図しない変更やバグが起きる可能性も高くなるということです。そのため、必要なものだけを public にすることが大切です。

2. C#のアクセス修飾子とは

C#には、public 以外にも複数のアクセス修飾子があります。アクセス修飾子を理解すると、クラスやメソッドを安全に設計できるようになります。

代表的なアクセス修飾子には、次のようなものがあります。

C#
public
private
protected
internal
protected internal
private protected

これらはすべて、「どこからアクセスできるか」を制御するために使います。

2-1. アクセス修飾子の役割

アクセス修飾子の役割は、プログラム内の要素に対してアクセス範囲を設定することです。

たとえば、次のようなクラスがあるとします。

C#
public class Sample
{
    public int PublicValue;
    private int PrivateValue;
}

PublicValue は public なので外部からアクセスできます。

C#
Sample sample = new Sample();
sample.PublicValue = 10;

一方、PrivateValue は private なので外部からアクセスできません。

C#
sample.PrivateValue = 20;

このコードはエラーになります。

アクセス修飾子を使うことで、「外部に見せるもの」と「内部に隠すもの」を分けることができます。

2-2. public・private・protected・internalの概要

C#でよく使われるアクセス修飾子を簡単に整理すると、次のようになります。

初心者が最初にしっかり覚えるべきなのは、まず public と private です。

public は外部に公開するもの、private は内部に隠すものです。この2つを理解すると、C#のクラス設計がかなりわかりやすくなります。

2-3. アクセス範囲を制御する理由

アクセス範囲を制御する理由は、プログラムを安全で保守しやすくするためです。

たとえば、次のように残高を public フィールドとして公開してしまうと、外部から自由に変更できてしまいます。

C#
public class BankAccount
{
    public int Balance;
}

この場合、次のようなコードも書けてしまいます。

C#
BankAccount account = new BankAccount();
account.Balance = -100000;

残高がマイナスになるなど、本来許可したくない状態になってしまう可能性があります。

そこで、フィールドは private にして、値の変更は public メソッド経由にします。

C#
public class BankAccount
{
    private int balance;

    public void Deposit(int amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }

    public int GetBalance()
    {
        return balance;
    }
}

このようにすると、不正な値を防ぎやすくなります。

2-4. オブジェクト指向プログラミングとの関係

C#はオブジェクト指向プログラミングに対応した言語です。オブジェクト指向では、データと処理をクラスにまとめて扱います。

そのときに重要になる考え方が「カプセル化」です。

カプセル化とは、クラスの内部状態を外部から直接操作できないようにし、必要な操作だけを公開する考え方です。

C#
public class Player
{
    private int hp;

    public void Damage(int value)
    {
        if (value > 0)
        {
            hp -= value;
        }
    }

    public int GetHp()
    {
        return hp;
    }
}

この例では、hp は private にして外部から直接変更できないようにしています。一方で、ダメージを与える Damage メソッドとHPを取得する GetHp メソッドは public にしています。

このように、public はクラスの外側に見せる操作を定義するために使います。private と組み合わせることで、安全でわかりやすいクラス設計ができます。

3. publicの基本的な使い方

ここからは、C#における public の基本的な使い方を具体的に見ていきます。

public は、クラス、メソッド、プロパティ、フィールドなどに付けることができます。

3-1. public classの使い方

public class は、クラスを外部から使えるようにするための書き方です。

C#
public class Person
{
}

このように書くと、Person クラスは他のクラスや別のファイルから利用できます。

たとえば、次のようにインスタンスを作成できます。

C#
Person person = new Person();

複数のファイルに分けて開発する場合、クラスを外部から使いたいなら public class にすることが多いです。

C#
// Person.cs
public class Person
{
    public string Name { get; set; }
}

C#
// Program.cs
Person person = new Person();
person.Name = "山田";

Console.WriteLine(person.Name);

このように、public class にすることで、別ファイルのコードからクラスを使えるようになります。

3-2. publicメソッドの使い方

public メソッドは、クラスの外側から呼び出せるメソッドです。

C#
public class Greeting
{
    public void SayHello()
    {
        Console.WriteLine("こんにちは");
    }
}

この SayHello メソッドは public なので、別の場所から呼び出せます。

C#
Greeting greeting = new Greeting();
greeting.SayHello();

実行結果は次のようになります。

C#
こんにちは

外部から実行してほしい処理には、public メソッドを使います。

たとえば、「ユーザーを登録する」「商品を表示する」「計算する」「データを保存する」など、他のクラスから呼び出す必要がある処理は public にすることがあります。

3-3. publicプロパティの使い方

C#では、クラスのデータを外部から取得・設定するためにプロパティをよく使います。

C#
public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

この場合、Name と Age は外部からアクセスできます。

C#
User user = new User();
user.Name = "鈴木";
user.Age = 25;

Console.WriteLine(user.Name);
Console.WriteLine(user.Age);

プロパティは、フィールドを直接公開するよりも柔軟に制御できます。

たとえば、値の取得は外部から許可し、設定はクラス内部だけにしたい場合は、次のように書けます。

C#
public class User
{
    public string Name { get; private set; }

    public User(string name)
    {
        Name = name;
    }
}

この場合、Name の取得は外部からできますが、設定はクラス内部からしかできません。

C#
User user = new User("田中");

Console.WriteLine(user.Name);

ただし、次のように外部から変更しようとするとエラーになります。

C#
user.Name = "佐藤";

このように、public プロパティは外部とのやり取りに便利です。

3-4. publicフィールドの使い方

public フィールドは、外部から直接アクセスできる変数です。

C#
public class Player
{
    public int Score;
}

この場合、次のように外部から値を設定できます。

C#
Player player = new Player();
player.Score = 100;

Console.WriteLine(player.Score);

ただし、C#では一般的に public フィールドよりも public プロパティが推奨されます。

理由は、フィールドを直接公開すると、値のチェックや変更時の処理を追加しにくくなるからです。

たとえば、次のようにスコアにマイナス値を入れられてしまいます。

C#
player.Score = -100;

プロパティを使えば、値を設定するときにチェックできます。

C#
public class Player
{
    private int score;

    public int Score
    {
        get
        {
            return score;
        }
        set
        {
            if (value >= 0)
            {
                score = value;
            }
        }
    }
}

このように、外部に値を公開したい場合でも、フィールドよりプロパティを使う方が安全です。

3-5. サンプルコードで見るpublicの書き方

ここまでの内容をまとめたサンプルコードを見てみましょう。

C#
using System;

public class Student
{
    public string Name { get; set; }
    public int Score { get; set; }

    public void ShowInfo()
    {
        Console.WriteLine($"名前: {Name}");
        Console.WriteLine($"点数: {Score}");
    }
}

public class Program
{
    public static void Main()
    {
        Student student = new Student();

        student.Name = "佐藤";
        student.Score = 90;

        student.ShowInfo();
    }
}

実行結果は次のようになります。

C#
名前: 佐藤
点数: 90

このコードでは、Student クラス、Name プロパティ、Score プロパティ、ShowInfo メソッドが public になっています。

そのため、Program クラスの Main メソッドから Student クラスを作成し、プロパティに値を設定し、メソッドを呼び出せます。

4. publicとprivateの違い

C#を学ぶうえで、public と private の違いは非常に重要です。

簡単にいうと、public は外部からアクセスできるもの、private はクラス内部からしかアクセスできないものです。

4-1. publicとprivateのアクセス範囲の違い

public は、クラスの外部からアクセスできます。

C#
public class Sample
{
    public int Number;
}

C#
Sample sample = new Sample();
sample.Number = 10;

一方、private は同じクラスの中からしかアクセスできません。

C#
public class Sample
{
    private int number;
}

次のコードはエラーになります。

C#
Sample sample = new Sample();
sample.number = 10;

number は private なので、Sample クラスの外側からは使えません。

4-2. 外部から呼び出せるかどうかの違い

メソッドの場合も同じです。

C#
public class Sample
{
    public void PublicMethod()
    {
        Console.WriteLine("publicメソッドです");
    }

    private void PrivateMethod()
    {
        Console.WriteLine("privateメソッドです");
    }
}

外部から呼び出せるのは PublicMethod だけです。

C#
Sample sample = new Sample();
sample.PublicMethod();

次のように PrivateMethod を呼び出そうとするとエラーになります。

C#
sample.PrivateMethod();

private メソッドは、同じクラスの内部から呼び出すために使います。

C#
public class Sample
{
    public void Execute()
    {
        PrivateMethod();
    }

    private void PrivateMethod()
    {
        Console.WriteLine("内部処理です");
    }
}

この場合、外部からは Execute を呼び出し、その中で PrivateMethod が実行されます。

4-3. クラス設計における使い分け

クラス設計では、外部から使ってほしいものを public にし、内部だけで使うものを private にします。

たとえば、注文処理を表すクラスを考えます。

C#
public class OrderService
{
    public void CreateOrder()
    {
        ValidateOrder();
        SaveOrder();
        SendMail();
    }

    private void ValidateOrder()
    {
        Console.WriteLine("注文内容をチェックします");
    }

    private void SaveOrder()
    {
        Console.WriteLine("注文を保存します");
    }

    private void SendMail()
    {
        Console.WriteLine("メールを送信します");
    }
}

外部から呼び出す必要があるのは CreateOrder だけです。

ValidateOrder、SaveOrder、SendMail は、注文作成の内部処理なので private にしています。

このようにすることで、外部のコードは細かい内部処理を意識せず、CreateOrder だけを呼び出せばよくなります。

4-4. publicにすべきもの・privateにすべきもの

public にすべきものは、外部から利用する必要があるものです。

たとえば、次のようなものです。

一方、private にすべきものは、クラス内部だけで使うものです。

基本的な考え方は、「必要なものだけを public にする」です。

4-5. サンプルコードで比較するpublicとprivate

次のコードで、public と private の違いを確認してみましょう。

C#
using System;

public class Counter
{
    private int count;

    public void Add()
    {
        count++;
    }

    public int GetCount()
    {
        return count;
    }
}

public class Program
{
    public static void Main()
    {
        Counter counter = new Counter();

        counter.Add();
        counter.Add();

        Console.WriteLine(counter.GetCount());
    }
}

実行結果は次のようになります。

C#
2

このコードでは、count は private なので外部から直接変更できません。

C#
counter.count = 100;

このようなコードはエラーになります。

代わりに、外部からは public メソッドである Add や GetCount を使います。

この設計により、count の変更方法をクラス側で管理できます。

5. publicを使う具体例

ここでは、より実践的な public の使い方を見ていきます。

5-1. publicメソッドを別クラスから呼び出す例

次の例では、MessageService クラスの ShowMessage メソッドを別クラスから呼び出します。

C#
using System;

public class MessageService
{
    public void ShowMessage()
    {
        Console.WriteLine("メッセージを表示します");
    }
}

public class Program
{
    public static void Main()
    {
        MessageService service = new MessageService();
        service.ShowMessage();
    }
}

ShowMessage が public なので、Program クラスから呼び出せます。

もし ShowMessage が private だった場合、外部から呼び出せないためエラーになります。

C#
private void ShowMessage()
{
    Console.WriteLine("メッセージを表示します");
}

5-2. publicプロパティで値を取得・設定する例

次の例では、Product クラスに public プロパティを定義しています。

C#
using System;

public class Product
{
    public string Name { get; set; }
    public int Price { get; set; }
}

public class Program
{
    public static void Main()
    {
        Product product = new Product();

        product.Name = "ノートPC";
        product.Price = 120000;

        Console.WriteLine(product.Name);
        Console.WriteLine(product.Price);
    }
}

実行結果は次のようになります。

C#
ノートPC
120000

Name と Price が public なので、外部から値を設定したり取得したりできます。

ただし、実務では価格にマイナス値が入らないようにするなど、必要に応じて制御を追加します。

C#
public class Product
{
    private int price;

    public int Price
    {
        get
        {
            return price;
        }
        set
        {
            if (value >= 0)
            {
                price = value;
            }
        }
    }
}

このように、public プロパティを使うと、外部に公開しながら内部で値の制御もできます。

5-3. public classを別ファイルから使う例

C#では、クラスを複数のファイルに分けて書くことがよくあります。

たとえば、次のように Animal.cs と Program.cs に分けたとします。

C#
// Animal.cs
public class Animal
{
    public void Speak()
    {
        Console.WriteLine("鳴き声を出します");
    }
}

C#
// Program.cs
public class Program
{
    public static void Main()
    {
        Animal animal = new Animal();
        animal.Speak();
    }
}

Animal クラスが public なので、別ファイルの Program.cs から利用できます。

ただし、別の名前空間にある場合は、using を追加する必要があります。

C#
using MyApp.Models;

また、別プロジェクトのクラスを使う場合は、参照設定が必要です。

5-4. Unityでpublicを使う場合の例

UnityでもC#の public はよく使われます。特に、MonoBehaviour を継承したクラスで public フィールドを使うと、UnityエディターのInspectorに表示されます。

C#
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float speed = 5.0f;

    void Update()
    {
        float x = Input.GetAxis("Horizontal");
        transform.Translate(x * speed * Time.deltaTime, 0, 0);
    }
}

この例では、speed が public なので、UnityのInspector上で値を変更できます。

ただし、C#の設計としては、何でも public フィールドにするのはおすすめされません。UnityではInspectorに表示したいけれど外部からは直接変更されたくない場合、次のように書くこともあります。

C#
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    [SerializeField]
    private float speed = 5.0f;
}

[SerializeField] を使うと、フィールド自体は private のまま、Inspectorに表示できます。

Unityでは public を使う機会が多いですが、C#の基本としては「外部に公開する必要があるものだけ public にする」という考え方を持っておくとよいです。

5-5. コンソールアプリでpublicを使う場合の例

コンソールアプリでも public はよく使います。

C#
using System;

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }
}

public class Program
{
    public static void Main()
    {
        Calculator calculator = new Calculator();

        int result1 = calculator.Add(10, 5);
        int result2 = calculator.Subtract(10, 5);

        Console.WriteLine(result1);
        Console.WriteLine(result2);
    }
}

実行結果は次のようになります。

C#
15
5

Add と Subtract は外部から呼び出す計算機能なので public にしています。

一方で、計算の補助処理など外部から呼び出す必要がない処理は private にします。

C#
public class Calculator
{
    public int AddTax(int price)
    {
        return CalculateTaxIncludedPrice(price);
    }

    private int CalculateTaxIncludedPrice(int price)
    {
        return (int)(price * 1.1);
    }
}

このように、外部に公開するメソッドと内部処理を分けることで、クラスの使い方がわかりやすくなります。

6. publicを使うときの注意点

public は便利ですが、使い方を間違えると保守性が下がったり、バグの原因になったりします。

6-1. 何でもpublicにすると保守性が下がる

初心者のうちは、アクセスできないエラーを避けるために、すべてを public にしたくなることがあります。

C#
public class Player
{
    public int hp;
    public int attack;
    public int defense;
}

このようにすると、どこからでも自由に値を変更できてしまいます。

C#
player.hp = -999;
player.attack = 999999;

小さなプログラムでは問題にならないように見えても、規模が大きくなると「どこで値が変更されたのか」がわかりにくくなります。

その結果、バグの原因を探すのが難しくなります。

保守性を高めるには、外部から直接変更されたくない値は private にし、必要な操作だけを public メソッドやプロパティとして公開します。

6-2. publicフィールドよりプロパティが推奨される理由

C#では、外部に値を公開したい場合、public フィールドよりも public プロパティがよく使われます。

C#
public class User
{
    public string Name { get; set; }
}

プロパティを使うと、後から処理を追加しやすくなります。

たとえば、名前が空文字の場合は設定しないようにできます。

C#
public class User
{
    private string name;

    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                name = value;
            }
        }
    }
}

最初は自動実装プロパティで書いておき、必要になったら処理を追加できます。

C#
public string Name { get; set; }

この書き方はシンプルで、初心者にも扱いやすいです。

6-3. 外部に公開する必要があるものだけpublicにする

public は、外部から使う必要があるものにだけ付けるのが基本です。

たとえば、次のように注文処理を作る場合、外部から必要なのは CreateOrder だけです。

C#
public class OrderService
{
    public void CreateOrder()
    {
        CheckStock();
        SaveOrder();
    }

    private void CheckStock()
    {
        Console.WriteLine("在庫を確認します");
    }

    private void SaveOrder()
    {
        Console.WriteLine("注文を保存します");
    }
}

CheckStock や SaveOrder を外部から直接呼び出せるようにしてしまうと、正しい順番で処理されない可能性があります。

内部処理は private にして、外部からは安全な入口だけを public にすることが重要です。

6-4. カプセル化を意識した使い方

public を使うときは、カプセル化を意識しましょう。

カプセル化とは、クラスの内部状態を隠し、外部からは必要な操作だけを使えるようにする考え方です。

C#
public class Character
{
    private int hp = 100;

    public void TakeDamage(int damage)
    {
        if (damage > 0)
        {
            hp -= damage;
        }

        if (hp < 0)
        {
            hp = 0;
        }
    }

    public int Hp
    {
        get
        {
            return hp;
        }
    }
}

この例では、hp は private にして、外部から直接変更できないようにしています。

外部からHPを減らす場合は、public メソッドの TakeDamage を使います。HPを確認する場合は、public プロパティの Hp を使います。

C#
Character character = new Character();

character.TakeDamage(30);
Console.WriteLine(character.Hp);

このように、public は「安全に使える操作を公開するためのもの」と考えるとよいです。

6-5. セキュリティやバグ防止の観点での注意点

public にしたメンバーは、他のコードから自由に呼び出せます。そのため、想定外の値が入ったり、想定外の順番で処理が呼ばれたりする可能性があります。

たとえば、次のようなコードは危険です。

C#
public class User
{
    public bool IsAdmin;
}

外部から自由に IsAdmin を変更できるため、管理者権限を簡単に変更できてしまいます。

C#
user.IsAdmin = true;

このような重要な情報は、外部から直接変更できないようにします。

C#
public class User
{
    public bool IsAdmin { get; private set; }

    public void GrantAdmin()
    {
        IsAdmin = true;
    }
}

さらに、権限を付与する条件が必要な場合は、メソッドの中でチェックを行います。

C#
public void GrantAdmin(bool hasPermission)
{
    if (hasPermission)
    {
        IsAdmin = true;
    }
}

public にするということは、外部から使われる可能性があるということです。安全性やバグ防止の観点からも、公開する範囲は慎重に決めましょう。

7. publicに関する初心者がつまずきやすいポイント

csharp public を学んでいる初心者がつまずきやすいポイントを整理します。

7-1. publicを付けない場合のデフォルトのアクセス範囲

C#では、public などのアクセス修飾子を省略した場合、対象によってデフォルトのアクセス範囲が異なります。

トップレベルのクラスは、何も付けないと通常 internal になります。

C#
class User
{
}

これは次のような意味に近いです。

C#
internal class User
{
}

一方、クラスのメンバーは、何も付けないと通常 private になります。

C#
public class User
{
    string name;
}

これは次のような意味に近いです。

C#
public class User
{
    private string name;
}

つまり、public を省略したからといって、必ず外部から使えるわけではありません。

初心者が混乱しやすいポイントなので、クラスとメンバーでデフォルトが違うことを覚えておきましょう。

7-2. publicなのにアクセスできない原因

public を付けているのにアクセスできない場合、いくつかの原因が考えられます。

よくある原因は、クラス自体が public ではない場合です。

C#
class User
{
    public string Name { get; set; }
}

この場合、Name は public ですが、User クラス自体が internal です。別のプロジェクトから使おうとするとアクセスできないことがあります。

別プロジェクトから使いたい場合は、クラスも public にします。

C#
public class User
{
    public string Name { get; set; }
}

また、名前空間が違う場合は using が必要です。

C#
using MyApp.Models;

別プロジェクトのコードを使う場合は、プロジェクト参照が必要な場合もあります。

7-3. static publicとpublic staticの違い

C#では、public static と static public は基本的に同じ意味です。

C#
public static void Show()
{
    Console.WriteLine("表示します");
}

C#
static public void Show()
{
    Console.WriteLine("表示します");
}

どちらも、外部からクラス名を使って呼び出せる静的メソッドです。

ただし、一般的には public static の順番で書くことが多いです。

C#
public static void Main()
{
}

public はアクセス修飾子、static はインスタンスを作らずに使えることを表す修飾子です。

C#
public class MathHelper
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

呼び出すときは、インスタンスを作らずにクラス名から呼び出します。

C#
int result = MathHelper.Add(3, 5);

7-4. クラスとメンバーでpublicの意味が少し異なる点

public は、クラスに付ける場合とメンバーに付ける場合で、少し意識するポイントが異なります。

クラスに付ける public は、そのクラス自体を外部から使えるようにするものです。

C#
public class User
{
}

メンバーに付ける public は、そのクラスのインスタンスやクラス名を通じて外部から利用できるようにするものです。

C#
public class User
{
    public string Name { get; set; }

    public void Login()
    {
        Console.WriteLine("ログインしました");
    }
}

ただし、メンバーが public でも、クラス自体にアクセスできなければ外部から使えません。

C#
class User
{
    public string Name { get; set; }
}

このような場合、同じプロジェクト内では使えても、別プロジェクトからは使えないことがあります。

7-5. 名前空間や参照設定によるアクセスエラー

public にしているのにアクセスできない場合、アクセス修飾子ではなく名前空間や参照設定が原因のこともあります。

たとえば、次のように名前空間があるクラスを考えます。

C#
namespace MyApp.Models
{
    public class User
    {
        public string Name { get; set; }
    }
}

別のファイルから使うには、次のように using が必要です。

C#
using MyApp.Models;

public class Program
{
    public static void Main()
    {
        User user = new User();
    }
}

using を書かない場合は、完全修飾名で書くこともできます。

C#
MyApp.Models.User user = new MyApp.Models.User();

また、別プロジェクトにあるクラスを使うには、プロジェクト参照やアセンブリ参照が必要です。

public はアクセスを許可するキーワードですが、名前空間や参照設定まで自動的に解決してくれるわけではありません。

8. publicと他のアクセス修飾子の違い

C#には、public と private 以外にもアクセス修飾子があります。ここでは、それぞれの違いを整理します。

8-1. publicとprotectedの違い

public は、どこからでもアクセスできます。

C#
public class Animal
{
    public void Eat()
    {
        Console.WriteLine("食べます");
    }
}

protected は、そのクラス自身と、継承したクラスからアクセスできます。

C#
public class Animal
{
    protected void Eat()
    {
        Console.WriteLine("食べます");
    }
}

public class Dog : Animal
{
    public void Run()
    {
        Eat();
    }
}

この場合、Dog クラスは Animal を継承しているため、Eat を呼び出せます。

しかし、外部から直接呼び出すことはできません。

C#
Dog dog = new Dog();
dog.Eat();

このコードはエラーになります。

protected は、継承先で使わせたいけれど、一般の外部コードには公開したくない場合に使います。

8-2. publicとinternalの違い

public は、別のアセンブリからもアクセスできます。

一方、internal は同じアセンブリ内からのみアクセスできます。初心者向けに言うと、同じプロジェクト内だけで使える、と考えると理解しやすいです。

C#
internal class InternalService
{
    public void Execute()
    {
        Console.WriteLine("内部サービスを実行します");
    }
}

このクラスは、同じプロジェクト内では使えますが、別プロジェクトからは通常アクセスできません。

ライブラリ開発では、外部の利用者に公開したいクラスは public、内部だけで使うクラスは internal にすることがあります。

8-3. publicとprotected internalの違い

protected internal は、少し特殊なアクセス修飾子です。

protected internal は、次のどちらかに当てはまる場合にアクセスできます。

同じアセンブリ内である場合、または派生クラスである場合です。

C#
public class BaseClass
{
    protected internal void Show()
    {
        Console.WriteLine("protected internalです");
    }
}

public よりは制限がありますが、protected や internal より広い範囲で使える場合があります。

ただし、初心者のうちは使用頻度はそれほど高くありません。まずは public、private、protected、internal を理解することを優先しましょう。

8-4. private protectedとの違い

private protected は、同じアセンブリ内にある派生クラスからアクセスできる修飾子です。

C#
public class BaseClass
{
    private protected void Show()
    {
        Console.WriteLine("private protectedです");
    }
}

protected internal は「同じアセンブリ、または派生クラス」ですが、private protected は「同じアセンブリ内の派生クラス」です。

つまり、private protected の方がアクセス範囲は狭くなります。

初心者が普段の学習で頻繁に使うことは多くありませんが、C#のアクセス修飾子を深く理解するうえでは知っておくとよいです。

8-5. アクセス修飾子の比較表

C#のアクセス修飾子を比較すると、次のようになります。

public は最も広いアクセス範囲を持つ修飾子です。そのため、使いすぎると外部から自由に操作できる範囲が広がりすぎます。

必要に応じて、private、protected、internal などを使い分けることが重要です。

9. publicの正しい使い分け方

public を正しく使い分けるには、「誰に使わせたいコードなのか」を考えることが大切です。

9-1. 外部に公開するAPIとして使う

public は、外部から使うためのAPIとして利用します。

APIというと難しく聞こえるかもしれませんが、ここでは「他のクラスから呼び出すための入口」と考えれば大丈夫です。

C#
public class UserService
{
    public void RegisterUser(string name)
    {
        Console.WriteLine($"{name}を登録しました");
    }
}

この RegisterUser は、外部から呼び出してユーザー登録を行うためのメソッドです。

C#
UserService service = new UserService();
service.RegisterUser("田中");

このように、他のクラスに使ってほしい機能は public にします。

9-2. クラス内部だけで使う処理はprivateにする

外部から直接呼び出す必要がない処理は private にします。

C#
public class UserService
{
    public void RegisterUser(string name)
    {
        ValidateName(name);
        SaveUser(name);
    }

    private void ValidateName(string name)
    {
        if (string.IsNullOrEmpty(name))
        {
            Console.WriteLine("名前が空です");
        }
    }

    private void SaveUser(string name)
    {
        Console.WriteLine($"{name}を保存しました");
    }
}

外部からは RegisterUser だけを呼び出せばよく、内部で ValidateName と SaveUser が実行されます。

このようにすると、外部のコードがクラスの内部処理に依存しにくくなります。

9-3. 継承先で使う場合はprotectedを検討する

メソッドやプロパティを外部には公開したくないけれど、継承先のクラスでは使いたい場合は protected を検討します。

C#
public class BaseController
{
    protected void Log(string message)
    {
        Console.WriteLine(message);
    }
}

public class UserController : BaseController
{
    public void Create()
    {
        Log("ユーザー作成処理を開始します");
    }
}

この場合、Log は外部から直接呼び出せませんが、BaseController を継承した UserController からは使えます。

すべてを public にするのではなく、継承先だけに見せたい場合は protected を使うとよいです。

9-4. 同じプロジェクト内だけで使う場合はinternalを検討する

ライブラリや大きなアプリケーションを作る場合、同じプロジェクト内だけで使うクラスには internal を使うことがあります。

C#
internal class FileHelper
{
    public void ReadFile()
    {
        Console.WriteLine("ファイルを読み込みます");
    }
}

このクラスは、同じアセンブリ内では使えますが、外部のプロジェクトからは使えません。

外部に公開する必要がないクラスまで public にしてしまうと、利用者に見せる必要のないクラスまで見えてしまいます。

そのため、外部に公開するクラスは public、内部だけで使うクラスは internal と使い分けるとよいです。

9-5. 迷ったときの判断基準

public にするか迷ったときは、次のように考えると判断しやすくなります。

基本的には、最初から広く公開しすぎないことが大切です。

迷ったときは、まず private にできないかを考えます。外部から本当に必要になった場合にだけ public にする方が、安全で保守しやすい設計になります。

10. publicの理解を深める練習問題

ここでは、csharp public の理解を深めるための練習問題を紹介します。実際にコードを書きながら確認すると、public と private の違いが身につきやすくなります。

10-1. publicメソッドを作成して呼び出す練習

次の条件を満たすクラスを作ってみましょう。

Greeting クラスを作成し、SayHello という public メソッドを定義します。そのメソッドを Main メソッドから呼び出してください。

解答例は次のとおりです。

C#
using System;

public class Greeting
{
    public void SayHello()
    {
        Console.WriteLine("こんにちは");
    }
}

public class Program
{
    public static void Main()
    {
        Greeting greeting = new Greeting();
        greeting.SayHello();
    }
}

SayHello は public なので、Program クラスから呼び出せます。

10-2. privateメソッドとの違いを確認する練習

次に、private メソッドとの違いを確認してみましょう。

C#
using System;

public class Greeting
{
    private void SayHello()
    {
        Console.WriteLine("こんにちは");
    }
}

public class Program
{
    public static void Main()
    {
        Greeting greeting = new Greeting();
        greeting.SayHello();
    }
}

このコードはエラーになります。

理由は、SayHello が private なので、Greeting クラスの外側にある Program クラスから呼び出せないためです。

private メソッドを使いたい場合は、同じクラス内の public メソッドから呼び出します。

C#
using System;

public class Greeting
{
    public void Execute()
    {
        SayHello();
    }

    private void SayHello()
    {
        Console.WriteLine("こんにちは");
    }
}

public class Program
{
    public static void Main()
    {
        Greeting greeting = new Greeting();
        greeting.Execute();
    }
}