Solidity language allows specifying accessibility for contract functions and state variables. That will enable us to set constraints on constructing the smart contract and whether other contracts or addresses can access the data. Contract state variables and functions have a slight difference that we're going to check out. I want to mention that accessibility and visibility are different things in blockchain development context.
Functions in smart contracts can have four accessibility levels.
When a function is defined as public it can be called from any other contract, including a smart contract that contains it or address.
Keyword external means that a function can be called by other contracts or addresses. If we want to call an external function, we can do it using this keyword.
Internal functions can be called from the same smart contract or any other inherited from it.
Private functions aren't visible and can't be accessed from other smart contracts or addresses. These functions aren't accessible in contracts that inherit a smart contract where this function is defined.
Smart contract state variables can be public, internal and private.
Public state variables can be accessed from any smart contract, including those that hold them or any address. Solidity generates for the public state variable a getter function.
Similar to functions, internal state variables can be accessed from a contract that defined them or any other that inherits from a smart contract. Important to note that smart contract state variables are internal by default.
A private state variable has the same characteristics as functions. It can be accessed only within the same contract, not any other contracts.
In blockchain development, visibility and accessibility have a different meaning. Everything inside a smart contract can be visible because all transactions are open in a ledger that anyone can see. Private or internal prevents other contracts or addresses from modifying the data. It can be visible from the outside because nothing can be hidden on the blockchain. It means that you can restrict access to a state variable or a function, but it is visible.
Solidity programming language has multiple options to define access levels for smart contract functions and state variables. In blockchain development, visibility and accessibility aren't the same. We can restrict access to the functions or state variables, but it can be viewed from the outside.