Write me a java project named pontoon game, which needs to meet the following requirements:Pontoon is a card game played with three decks of playing cards (i.e. cards of 2-10, Jack, Queen, King, and Ace from the four suits of Hearts, Diamonds, Spades, and Clubs). There are two players: the user of the computer, and the computer itself. The object of the game is to beat the other player by either getting as close to a score of 21 as possible (without exceeding 21) or by having 5 cards and a score of 21 or less. Each card has a value: numeric cards have their numeric value, 'face' cards have value 10, and aces have value 11. The game is played as follows, Firstly the user is told about the game and invited to play. If they opt to play then four cards are dealt. The first card goes to the user, the second to the computer, the third to the user, and the fourth to the computer. The computer's card remains hidden, all others are shown. The user can then indicate they wish to have an additional card ("hit"). If they are this card is also displayed. Additional cards may be taken until either the user's score exceeds 21 (they "bust"), or they choose not to take another card ("sit"/"stand"). Once the user has finished taking cards the computer will take cards. The computer will always take a card if their total is less than 16 (and the user's score doesn't exceed 21).

Sure, here is an implementation of the Pontoon game in Java:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class PontoonGame {
    private static final int MAX_SCORE = 21;
    private static final int MAX_NUM_CARDS = 5;
    private static final int DEALER_STAND_THRESHOLD = 16;
    private static final int CARD_VALUE_ACE = 11;
    private static final int CARD_VALUE_FACE = 10;

    private static final String[] SUITS = new String[] { "Hearts", "Diamonds", "Spades", "Clubs" };
    private static final String[] RANKS = new String[] { "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace" };

    private List<Card> deck;
    private List<Card> playerHand;
    private List<Card> dealerHand;

    public PontoonGame() {
        deck = new ArrayList<>();
        playerHand = new ArrayList<>();
        dealerHand = new ArrayList<>();

        // Initialize deck
        for (String suit : SUITS) {
            for (String rank : RANKS) {
                deck.add(new Card(rank, suit));
            }
        }
    }

    public void play() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Welcome to Pontoon! Would you like to play? (y/n)");
        String input = scanner.nextLine();
        if (!input.equalsIgnoreCase("y")) {
            return;
        }

        // Shuffle deck and deal cards
        Collections.shuffle(deck);
        playerHand.add(dealCard());
        dealerHand.add(dealCard());
        playerHand.add(dealCard());
        dealerHand.add(dealCard());

        // Show initial hands
        System.out.println("Your hand: " + playerHand);
        System.out.println("Dealer's hand: " + dealerHand.get(0) + ", [hidden]");

        // Player's turn
        while (true) {
            System.out.println("Would you like to hit or stand? (h/s)");
            input = scanner.nextLine();
            if (input.equalsIgnoreCase("h")) {
                playerHand.add(dealCard());
                System.out.println("Your hand: " + playerHand);
                if (getHandValue(playerHand) > MAX_SCORE) {
                    System.out.println("Bust! You lose.");
                    return;
                }
            } else if (input.equalsIgnoreCase("s")) {
                break;
            } else {
                System.out.println("Invalid input. Please enter 'h' or 's'.");
            }
        }

        // Dealer's turn
        while (getHandValue(dealerHand) < DEALER_STAND_THRESHOLD && getHandValue(playerHand) <= MAX_SCORE) {
            dealerHand.add(dealCard());
        }
        System.out.println("Dealer's hand: " + dealerHand);

        // Determine winner
        int playerScore = getHandValue(playerHand);
        int dealerScore = getHandValue(dealerHand);
        if (playerScore > MAX_SCORE) {
            System.out.println("Bust! You lose.");
        } else if (dealerScore > MAX_SCORE) {
            System.out.println("Dealer busts! You win.");
        } else if (playerScore == dealerScore) {
            System.out.println("It's a tie!");
        } else if (playerScore == MAX_SCORE || dealerScore > MAX_SCORE || playerScore > dealerScore) {
            System.out.println("You win!");
        } else {
            System.out.println("Dealer wins!");
        }
    }

    private Card dealCard() {
        if (deck.isEmpty()) {
            throw new IllegalStateException("Deck is empty.");
        }
        return deck.remove(0);
    }

    private int getHandValue(List<Card> hand) {
        int value = 0;
        int numAces = 0;
        for (Card card : hand) {
            if (card.getRank().equals("Ace")) {
                numAces++;
            } else if (card.getRank().equals("Jack") || card.getRank().equals("Queen") || card.getRank().equals("King")) {
                value += CARD_VALUE_FACE;
            } else {
                value += Integer.parseInt(card.getRank());
            }
        }
        for (int i = 0; i < numAces; i++) {
            if (value + CARD_VALUE_ACE > MAX_SCORE) {
                value += 1;
            } else {
                value += CARD_VALUE_ACE;
            }
        }
        return value;
    }

    private static class Card {
        private final String rank;
        private final String suit;

        public Card(String rank, String suit) {
            this.rank = rank;
            this.suit = suit;
        }

        public String getRank() {
            return rank;
        }

        public String getSuit() {
            return suit;
        }

        @Override
        public String toString() {
            return rank + " of " + suit;
        }
    }

    public static void main(String[] args) {
        PontoonGame game = new PontoonGame();
        game.play();
    }
}

This implementation uses object-oriented programming principles to model the game as a `PontoonGame` class that contains methods for playing the game. The game logic is implemented in the `play()` method, which prompts the user for input, deals cards, and determines the winner. The `Card` class is a nested class that represents a playing card with a rank and a suit.