NOTICE
Role: You are a professional software engineer, and your main task is to review the code. You need to ensure that the code conforms to the PEP8 standards, is elegantly designed and modularized, easy to read and maintain, and is written in Python 3.9 (or in another programming language).
ATTENTION: Use '##' to SPLIT SECTIONS, not '#'. Output format carefully referenced "Format example".

## Code Review: Based on the following context and code, and following the check list, Provide key, clear, concise, and specific code modification suggestions, up to 5.
```
1. Check 0: Is the code implemented as per the requirements?
2. Check 1: Are there any issues with the code logic?
3. Check 2: Does the existing code follow the "Data structures and interface definitions"?
4. Check 3: Is there a function in the code that is omitted or not fully implemented that needs to be implemented?
5. Check 4: Does the code have unnecessary or lack dependencies?
```

## Rewrite Code: point.py Base on "Code Review" and the source code, rewrite code with triple quotes. Do your utmost to optimize THIS SINGLE FILE. 
-----
# Context
## Implementation approach
For the snake game, we can use the Pygame library, which is an open-source and easy-to-use library for game development in Python. Pygame provides a simple and efficient way to handle graphics, sound, and user input, making it suitable for developing a snake game.

## Python package name
```
"snake_game"
```
## File list
````
[
    "main.py",
]
```
## Data structures and interface definitions
```
classDiagram
    class Game:
        -int score
        -bool paused
        +__init__()
        +start_game()
        +handle_input(key: int)
        +update_game()
        +draw_game()
        +game_over()
    
    class Snake:
        -list[Point] body
        -Point dir
        -bool alive
        +__init__(start_pos: Point)
        +move()
        +change_direction(dir: Point)
        +grow()
        +get_head() -> Point
        +get_body() -> list[Point]
        +is_alive() -> bool
    
    class Point:
        -int x
        -int y
        +__init__(x: int, y: int)
        +set_coordinate(x: int, y: int)
        +get_coordinate() -> tuple[int, int]
    
    class Food:
        -Point pos
        -bool active
        +__init__()
        +generate_new_food()
        +get_position() -> Point
        +is_active() -> bool
    
    Game "1" -- "1" Snake: contains
    Game "1" -- "1" Food: has
```

## Program call flow
```
sequenceDiagram
    participant M as Main
    participant G as Game
    participant S as Snake
    participant F as Food
    
    M->>G: Start game
    G->>G: Initialize game
    loop
        M->>G: Handle user input
        G->>S: Handle input
        G->>F: Check if snake eats food
        G->>S: Update snake movement
        G->>G: Check game over condition
        G->>G: Update score
        G->>G: Draw game
        M->>G: Update display
    end
    G->>G: Game over
```
## Required Python third-party packages
```
"""
pygame==2.0.1
"""
```
## Required Other language third-party packages
```
"""
No third-party packages required for other languages.
"""
```

## Logic Analysis
```
[
    ["main.py", "Main"],
    ["game.py", "Game"],
    ["snake.py", "Snake"],
    ["point.py", "Point"],
    ["food.py", "Food"]
]
```
## Task list
```
[
    "point.py",
    "food.py",
    "snake.py",
    "game.py",
    "main.py"
]
```
## Shared Knowledge
```
"""
The 'point.py' module contains the implementation of the Point class, which represents a point in a 2D coordinate system.

The 'food.py' module contains the implementation of the Food class, which represents the food in the game.

The 'snake.py' module contains the implementation of the Snake class, which represents the snake in the game.

The 'game.py' module contains the implementation of the Game class, which manages the game logic.

The 'main.py' module is the entry point of the application and starts the game.
"""
```
## Anything UNCLEAR
We need to clarify the main entry point of the application and ensure that all required third-party libraries are properly initialized.

## Code: point.py
```
class Point:
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y

    def set_coordinate(self, x: int, y: int):
        self.x = x
        self.y = y

    def get_coordinate(self) -> tuple[int, int]:
        return self.x, self.y
```
-----

## Format example
-----
## Code Review
1. The code ...
2. ...
3. ...
4. ...
5. ...

## Rewrite Code: point.py
```python
## point.py
...
```
-----