#Convert a number into scientific format
#clcoding
a = '{:.0e}' .format(1111111111111)
b = '{:.0e}' .format(2222222222222)
print(a)
print(b)
Join us: https://t.me/jupyter_python
Build.gradle File:- implementation 'com.google.android.material:material:1.3.0'
implementation 'com.squareup.retrofit2:retrofit:2.8.1'
implementation 'com.squareup.retrofit2:converter-gson:2.8.1'
implementation 'com.squareup.okhttp3:logging-interceptor:4.6.0' Activity-main <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:orientation="vertical"
android:background="@color/colorWhite"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:text="Login to continue"
android:layout_marginTop="100dp"
android:textSize="24sp"
android:layout_gravity="center_horizontal"
android:textColor="@color/colorPrimaryDark"
android:layout_height="wrap_content" />
<com.google.android.material.textfield.TextInputLayout
android:layout_width="match_parent"
android:layout_marginTop="30dp"
android:layout_marginStart="30dp"
android:layout_marginEnd="30dp"
android:hint="Username"
android:layout_height="wrap_content">
<com.google.android.material.textfield.TextInputEditText
android:layout_width="match_parent"
android:inputType="text"
android:id="@+id/edUsername"
android:layout_height="wrap_content" />
</com.google.android.material.textfield.TextInputLayout>
<com.google.android.material.textfield.TextInputLayout
android:layout_width="match_parent"
android:layout_marginTop="30dp"
android:hint="Password"
android:layout_marginStart="30dp"
android:layout_marginEnd="30dp"
android:layout_height="wrap_content">
<com.google.android.material.textfield.TextInputEditText
android:layout_width="match_parent"
android:inputType="textPassword"
android:id="@+id/edPassword"
android:layout_height="wrap_content" />
</com.google.android.material.textfield.TextInputLayout>
<Button
android:layout_width="match_parent"
android:layout_margin="30dp"
android:text="Login"
android:id="@+id/btnLogin"
android:background="@color/colorPrimary"
android:textColor="@color/colorWhite"
android:layout_height="wrap_content" />
</LinearLayout> Java File :- 1. Api Client import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class ApiClient {
private static Retrofit getRetrofit(){
HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(httpLoggingInterceptor).build();
Retrofit retrofit = new Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create())
.baseUrl("http://api.irawen.net/") //Change server URL
.client(okHttpClient)
.build();
return retrofit;
}
public static UserService getUserService(){
UserService userService = getRetrofit().create(UserService.class);
return userService;
}
}
2. Login Request :- public class LoginRequest {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
3. Login response :- public class LoginResponse {
private int user_id;
private String email;
private String username;
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
} 4. Main Activity :- import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import com.google.android.material.textfield.TextInputEditText;
import androidx.appcompat.app.AppCompatActivity;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
public class MainActivity extends AppCompatActivity {
TextInputEditText username, password;
Button btnLogin;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
username = findViewById(R.id.edUsername);
password = findViewById(R.id.edPassword);
btnLogin = findViewById(R.id.btnLogin);
btnLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if(TextUtils.isEmpty(username.getText().toString()) || TextUtils.isEmpty(password.getText().toString())){
Toast.makeText(MainActivity.this,"Username / Password Required", Toast.LENGTH_LONG).show();
}else{
//proceed to login
login();
}
}
});
}
public void login(){
LoginRequest loginRequest = new LoginRequest();
loginRequest.setUsername(username.getText().toString());
loginRequest.setPassword(password.getText().toString());
Call<LoginResponse> loginResponseCall = ApiClient.getUserService().userLogin(loginRequest);
loginResponseCall.enqueue(new Callback<LoginResponse>() {
@Override
public void onResponse(Call<LoginResponse> call, Response<LoginResponse> response) {
if(response.isSuccessful()){
Toast.makeText(MainActivity.this,"Login Successful", Toast.LENGTH_LONG).show();
LoginResponse loginResponse = response.body();
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
startActivity(new Intent(MainActivity.this,DashboardActivity.class).putExtra("data",loginResponse.getUsername()));
}
},700);
}else{
Toast.makeText(MainActivity.this,"Login Failed", Toast.LENGTH_LONG).show();
}
}
@Override
public void onFailure(Call<LoginResponse> call, Throwable t) {
Toast.makeText(MainActivity.this,"Throwable "+t.getLocalizedMessage(), Toast.LENGTH_LONG).show();
}
});
}
}
5. User Service :-import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.POST;
public interface UserService {
@POST("authenticate/")
Call<LoginResponse> userLogin(@Body LoginRequest loginRequest);
}
class A
{
public void abc(int q)
{
Console.WriteLine("abc from A");
}
}
class B : A
{
public void abc(double p)
{
Console.WriteLine("abc from B");
}
}
static void Main(string[] args)
{
int i = 5;
B b = new B();
b.abc(i);
Console.ReadLine();
}
Answer :-
abc from B.
class Program
{
static void Main(string[] args)
{
MyClassB b = new MyClassB();
MyClassA a = b;
a.abc();
Console.ReadLine();
}
}
class MyClassA
{
public MyClassA()
{
Console.WriteLine("constructor A");
}
public void abc()
{
Console.WriteLine("A");
}
}
class MyClassB:MyClassA
{
public MyClassB()
{
Console.WriteLine("constructor B");
}
public void abc()
{
Console.WriteLine("B");
}
}
constructor A
constructor B
A
During initialization of the B class, the constructor of the A class will be executed by default, then constructor of the B class. After assignment of the b value to a type variable of the A class, we will get an instance of the B class in it. One would think that abc() from the B class should be called, but since there is no specification of any predicate of the abc method in the B class, it hides abc from the A class. The example is not quite correct and abc() in the B class will be underlined, since the new predicate is required.
Static Constructors Vs Non-Static Constructors :
If a constructor is explicitly declared by using a static modifier we call that constructor as static constructor whereas rest of other are non-static constructor only.
Constructors are responsible for initializing fields/variables of a class, static fields are initialized by static constructors and non-static fields are initialized by non-static constructors.
Static constructors are implicitly called whereas non-static constructors must be explicitly called.
Static constructors executes immediately once the execution of a class starts and more over it's the first block of code to run under a class whereas non-static constructors executes only after creating the instance of class as well as each and every time the instance of class is created.
In the life cycle of a class static constructors executes one and only one time whereas non-static constructors executes for zero times if no instances are created and "n" times if "n" instances are created.
Non-static constructors can be parameterized but static constructors can't have any parameters because static constructors are implicitly called and more over it's the first block of code to run under class.
Non-static constructors can be overloaded where as static constructors can't be overloaded.
// C# Program to demonstrate
// how to declare the static
// constructor and non-static
// constructor
using System;
class ABC{
// Static variable
static int s;
// Non-static variable
int ns;
// Declaration of
// static constructor
static ABC()
{
Console.WriteLine("It is static constructor");
}
// Declaration of
// non-static constructor
public ABC()
{
Console.WriteLine("It is non-static constructor");
}
// Main Method
static void Main(string[] args)
{
// Static constructor will call implicitly
// as soon as the class start to execute
// the first block of code to execute
// will be static constructor
// Calling non-static constructor
ABC obj1 = new ABC();
}
}
Output :
It is static constructor
It is non-static constructor
Every class contains an implicit constructor if not defined explicitly and those implicit constructors are defined based on the following criteria :
⟶ Every class except a static class contains an implicit non-static constructor if not defined with an explicit constructors .
⟶ Static constructors are implicitly defined only if that class contains any static fields or else that constructor will not be present at all.
Every class requires a constructor to be present init if we want to create the instance of that class.
Every class contains an implicit constructor if not defined explicitly and with the help of that implicit constructor instance of class can be created.
What is the need of defining a constructor explicitly again ?
Implicit constructor of a class will initialize variables of a class with the same value even if we create multiple instance of that class.
If we define constructor explicitly with parameters then we get a change of initializing the fields or variables of the class with a new value every time we are going to create instance of that class.
When ever we define a class identify whether if the class variables requires some values to execute and if they are required then define a constructor explicitly and pass values thru that constructor , so that every time the instance of the class is created we get a chance of passing new values.
Note : Generally every class requires some values for execution and the values that is required for a class to execute are always sent to that class by using the constructor only.
Type of Constructors
1. Default or Parameter Less Constructor
2. Parameterized Constructor
3. Copy Constructor
4. Static Constructor
Default or Parameter Less Constructor :
If a constructor method doesn't take any parameters then we call that as default or parameter less. these constructors can be defined by a programmer explicitly or else will be default implicitly provided there is no explicit constructor under the class.
class Test
{
public Test () //Implicit Constructor
{
}
}
Parameterized Constructor :
If a constructor method is defined with out any parameters we call that as parameterized constructor and these constructor can be defined by the programmers only but never can be defined implicitly.
Copy Constructor :
If we want to create multiple instances with the same values then we use these copy constructors, in a copy constructors the constructors takes the same class as a parameters to it.
Static Constructor :
If a constructor is explicitly declared by using static modifier we call that as static constructor. All the constructors we have defined till now are non-static or instance constructors.
Class Test
{
static Test () //Static constructor defined explicitly
{
}
public Test () // Implicit default constructor
{
}
}
If a class contains any static the only implicit static constructors will be present or else we need to define them explicitly whereas non-static constructors will be implicitly defined in every class (except static class) provided we did not define them explicitly.
Static constructor are responsible in initializing static variables and these constructors are never called explicitly they are implicitly called and more over these constructor are first to execute under any class.
Static constructors can't be parameterized so overloading static constructors is not possible.
It's a special method present under a class responsible for initializing the variable of that class.
The name of a constructor method is exactly the same name of the class in which it was present and more over it's a non-value returning method.
Each and every class requires this constructor if we want to create the instance of that class.
class Test
{
int i ;
}
Test obj = new Test(); // Valid
⟶ It's the responsibility of a programmer to define a constructor under his class and if he fails to do so, on behalf of the programmer an implicit constructor gets defined in that class by the compiler.
class Test
{
int i ; string s; bool b;
public Test ()
{
i = 0; // Initializing the variables
s = null;
b = false;
}
}
Implicitly defined constructors are parameter less and these constructor are also known as default constructors.
Implicitly defined co0nstructor are public.
We can also defined a constructor under the class and if we define it we can call it as explicit constructor and explicit constructor can be parameter less or parameterized also.
[ < modifiers > ] <Name> ( [ < parameter list > ] )
{
-Stmts
}
Defining : Implicit or Explicit
Calling : Explicit
.png)
.png)
Posts
All Comments
