protected HttpURLConnection(URL url) 
{
        super(url);
}

Constructs a new {@code HttpURLConnection} instance pointing to the resource specified by the {@code url}.

Parameters:

url - the URL of this connection.

Also see:

URL
URLConnection

 abstract public  void disconnect()
Closes the connection to the HTTP server.

 public InputStream getErrorStream() 
{
        return null;
}

Returns an input stream from the server in the case of an error such as the requested file has not been found on the remote server. This stream can be used to read the data the server will send back.

 public static boolean getFollowRedirects() 
{
        return followRedirects;
}

Returns the value of {@code followRedirects} which indicates if this connection follows a different URL redirected by the server. It is enabled by default.

 public long getHeaderFieldDate(String field,
    long defaultValue) 
{
        return super.getHeaderFieldDate(field, defaultValue);
}

Returns the date value in milliseconds since {@code 01.01.1970, 00:00h} corresponding to the header field {@code field}. The {@code defaultValue} will be returned if no such field can be found in the response header.

 public boolean getInstanceFollowRedirects() 
{
        return instanceFollowRedirects;
}

Returns whether this connection follows redirects.

 public Permission getPermission() throws IOException 
{
        int port = url.getPort();
        if (port <  0) {
            port = 80;
        }
        return new SocketPermission(url.getHost() + ":" + port, //$NON-NLS-1$
                "connect, resolve"); //$NON-NLS-1$
}

Returns the permission object (in this case {@code SocketPermission}) with the host and the port number as the target name and {@code "resolve, connect"} as the action list. If the port number of this URL instance is lower than {@code 0} the port will be set to {@code 80}.

 public String getRequestMethod() 
{
        return method;
}

Returns the request method which will be used to make the request to the remote HTTP server. All possible methods of this HTTP implementation is listed in the class definition.

 public int getResponseCode() throws IOException 
{
        // Call getInputStream() first since getHeaderField() doesn't return
        // exceptions
        getInputStream();
        String response = getHeaderField(0);
        if (response == null) {
            return -1;
        }
        response = response.trim();
        int mark = response.indexOf(" ") + 1; //$NON-NLS-1$
        if (mark == 0) {
            return -1;
        }
        int last = mark + 3;
        if (last  > response.length()) {
            last = response.length();
        }
        responseCode = Integer.parseInt(response.substring(mark, last));
        if (last + 1 < = response.length()) {
            responseMessage = response.substring(last + 1);
        }
        return responseCode;
}

Returns the response code returned by the remote HTTP server.

 public String getResponseMessage() throws IOException 
{
        if (responseMessage != null) {
            return responseMessage;
        }
        getResponseCode();
        return responseMessage;
}

Returns the response message returned by the remote HTTP server.

 public  void setChunkedStreamingMode(int chunklen) 
{
        if (super.connected) {
            throw new IllegalStateException(Messages.getString("luni.5F")); //$NON-NLS-1$
        }
        if (0 < = fixedContentLength) {
            throw new IllegalStateException(Messages.getString("luni.60")); //$NON-NLS-1$
        }
        if (0  >= chunklen) {
            chunkLength = DEFAULT_CHUNK_LENGTH;
        } else {
            chunkLength = chunklen;
        }
}

If the length of a HTTP request body is NOT known ahead, enable chunked transfer encoding to enable streaming with buffering. Notice that not all http servers support this mode. Sets after connection will cause an exception.

 public  void setFixedLengthStreamingMode(int contentLength) 
{
        if (super.connected) {
            throw new IllegalStateException(Messages.getString("luni.5F")); //$NON-NLS-1$
        }
        if (0 <  chunkLength) {
            throw new IllegalStateException(Messages.getString("luni.60")); //$NON-NLS-1$
        }
        if (0  > contentLength) {
            throw new IllegalArgumentException(Messages.getString("luni.61")); //$NON-NLS-1$
        }
        this.fixedContentLength = contentLength;
}

If the length of a HTTP request body is known ahead, sets fixed length to enable streaming without buffering. Sets after connection will cause an exception.

 public static  void setFollowRedirects(boolean auto) 
{
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkSetFactory();
        }
        followRedirects = auto;
}

Sets the flag of whether this connection will follow redirects returned by the remote server. This method can only be called with the permission from the security manager.

 public  void setInstanceFollowRedirects(boolean followRedirects) 
{
        instanceFollowRedirects = followRedirects;
}

Sets whether this connection follows redirects.

 public  void setRequestMethod(String method) throws ProtocolException 
{
        if (connected) {
            throw new ProtocolException(Messages.getString("luni.5E")); //$NON-NLS-1$
        }
        for (int i = 0; i <  methodTokens.length; i++) {
            if (methodTokens[i].equals(method)) {
                // if there is a supported method that matches the desired
                // method, then set the current method and return
                this.method = methodTokens[i];
                return;
            }
        }
        // if none matches, then throw ProtocolException
        throw new ProtocolException();
}

Sets the request command which will be sent to the remote HTTP server. This method can only be called before the connection is made.

 abstract public boolean usingProxy()
Returns whether this connection uses a proxy server or not.