深入学习C#与Java：掌握Java基础语法的关键点

c#学Java &＃8211; Java基本语法

JAVA <->  .NET JVM  <-> CLR JDK  <->  FCL

类名称
应以大写字母开头，并成为容易理解的名词或组合。如：String, Color, Button, System, Thread等。

接口名称
应以大写字母开头，并作为形容词。如： Runnable，Remote，ActionListener等。

方法名称
应以小写字母开头，并作为动词。如：actionPerformed()，main()，print()，println()等。

变量名称
应以小写字母开头。如：firstName，orderNumber等。

包名称
应使用小写字母。如： java，lang，sql，util等。

常量名称
应使用大写字母。 例如：RED, YELLOW, MAX_PRIORITY等

一个对象有三个特点：

状态： 表示一个对象的数据(值)。

行为： 表示对象的行为(功能)，例如：存款，取款等。

标识： 对象标识通常通过唯一ID实现。该ID的值对外部用户不可见。 但是，它由JVM内部使用来唯一地标识每个对象。

对象是类的一个实例。 类是创建对象的模板或蓝图。 所以对象是一个类的实例。

对象定义：

对象是一个现实世界的实体。

对象是一个运行时实体。

对象是具有状态和行为的实体。

对象是类的一个实例。

在java中有很多方法可以用来创建对象。它们分别是：

通过new关键字

通过newInstance()方法

通过clone()方法

通过反序列化

通过工厂方法等

匿名只是表示没有名。没有引用的对象(也就是不使用实例变量)称为匿名对象。它只能在创建对象时使用。如果只需要使用一个对象，匿名对象是一个很好的方法。 例如：

new Calculation();//匿名对象
Calculation c = new Calculation();// 使用实例变量，所以不是匿名对象

构造函数基本上定义了两个规则:

构造函数名称必须与其类名称相同

构造函数必须没有显式返回类型

6.1 没参数的构造函数称为默认构造函数

默认构造函数的语法如下：

(){}

如果类中没有构造函数，编译器会自动创建一个默认构造函数。

默认构造函数根据类型为对象提供默认值，如：0，null等。

6.2 Java参数化构造函数

参数化构造函数用于为不同对象提供不同初始化的值。

6.3 Java构造函数重载

构造方法重载是Java中的一种技术，一个类可以有任何数量的参数列表不同的构造函数。编译器通过构造函数参数列表中的参数数量及其类型来区分这些构造函数。

java的构造函数和方法之间的区别

Java构造函数

Java方法

构造器用于初始化对象的状态(数据)。
方法用于暴露对象的行为。

构造函数不能有返回类型。
方法一般都有返回类型。

构造函数隐式调用。
方法要显式调用。

如果没有指定任何构造函数，java编译器提供一个默认构造函数。
在任何情况下编译器都不会提供默认的方法调用。

构造函数名称必须与类名称相同。
方法名称可以或可以不与类名称相同(随意)

6.4 Java拷贝构造函数

在Java中没有复制构造函数。但是可以将一个对象的值复制到另一个中，就像C++中的复制构造函数。

在java中有很多方法可以将一个对象的值复制到另一个对象中。它们分别是：

通过构造函数

通过将一个对象的值分配给另一个对象

*

Student6 s1 = new Student6(111, &＃8220;Karan&＃8221;);

Student6 s2 = new Student6(s1);

*

 Student7 s1 = new Student7(111, &＃8220;Karan&＃8221;);

 Student7 s2 = new Student7();

 s2.id = s1.id;

 s2.name = s1.name;

通过Object类的clone()方法

java中的static关键字主要用于内存管理。我们可以应用java static关键字在变量，方法，块和嵌套类中。 static关键字属于类，而不是类的实例。

静态(static)可以是：

变量(也称为类变量)

方法(也称为类方法)

代码块

嵌套类

7.1 Java静态变量

如果将一个变量声明为static，它就是所谓的静态变量了。

静态变量可以用于引用所有对象的公共属性(对于每个对象不是唯一的)。如：员工公司名称，学生所在的大学名称。

静态变量的优点：

它能使程序存储器高效(即它节省内存),Java静态属性被共享给所有对象。

7.2 Java静态方法

如果在任何方法上应用static关键字，此方法称为静态方法。

静态方法属于类，而不属于类的对象。

可以直接调用静态方法，而无需创建类的实例。

静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

*静态方法有两个主要限制：

静态方法不能直接使用非静态数据成员或调用非静态方法。

this和super两个关键字不能在静态上下文中使用。

为什么java main方法是静态的？

这是因为对象不需要调用静态方法，如果它是非静态方法，jvm首先要创建对象，然后调用main()方法，这将导致额外的内存分配的问题。

7.3 Java静态块

Java中的静态块主要有两个作用：

用于初始化静态数据成员。

它在类加载时在main方法之前执行。

class A2 {
static {
System.out.println("static block is invoked");
}
public static void main(String args[]) {
System.out.println("Hello main");
}
}

java 类中的静态域的初始化和静态代码块的执行只在类加载的时候执行且只执行一次。

*构建对象，就是用new class()语句建立一个新的类的对象。在这种情况下，类中的域是按照如下顺序进行初始化的：赋予默认值&＃8211;>（静态域、静态块）&＃8211;>（实例域、实例块）&＃8211;>构造器。

假设一个域即变量int a，当建立对象时，首先赋予它一个默认值，int类型的默认值为0；如果a为静态域并且在静态块中被赋值，那么就按照静态域和静态块在程序中出现的顺序先后执行；如果同时还在实例块中被赋值，则再执行实例块中的赋值语句（静态域不可能再是实例域）；最后执行构造器中的赋值语句（如果在构造器中有被赋值的话）。如果变量a是实例域，则不会有静态域和在静态块中赋值（不能在静态块中给实例域赋值）的情况，其他同前所述。

总结：静态域是指静态域在声明时被赋值，静态块是指在静态块中被赋值，实例域和实例块同上。上面列出的四个步骤是先后执行的；括号中的两种方式是同等级的，按照在程序中的顺序执行，排在前面的先执行，排在后面的后执行。

在java中，this关键字有很多种用法。 在java中，这是一个引用当前对象的引用变量。

java this关键字的用法如下：

this关键字可用来引用当前类的实例变量。

this关键字可用于调用当前类方法(隐式)。

this()可以用来调用当前类的构造函数。

this关键字可作为调用方法中的参数传递。

this关键字可作为参数在构造函数调用中传递。

this关键字可用于从方法返回当前类的实例。

8.1 this：引用当前类的实例变量

Student(int rollo, String name, float fee) {
this.rollo = rollo;
this.name = name;
this.fee = fee;
}


8.2 this：调用当前类方法

可以使用this关键字调用当前类的方法。如果不使用this关键字，编译器会在调用方法时自动添加此 this 关键字。类中函数的相互调用。

8.3 this()：调用当前类的构造函数

this()构造函数调用可以用来调用当前类的构造函数。 它用于重用构造函数。 换句话说，它用于构造函数链接。

使用this()构造函数调用

this()构造函数调用用于从构造函数重用构造函数。 它维护构造函数之间的链，即它用于构造函数链接。看看下面给出的示例，显示this关键字的实际使用。
this()必须是构造函数中的第一个语句

class Student {
int rollno;
String name, course;
float fee;
Student(int rollno, String name, String course) {
this.rollno = rollno;
this.name = name;
this.course = course;
}
Student(int rollno, String name, String course, float fee) {
this(rollno, name, course);// reusing constructor
this.fee = fee;
}
void display() {
System.out.println(rollno + " " + name + " " + course + " " + fee);
}
}
class TestThis7 {
public static void main(String args[]) {
Student s1 = new Student(111, "ankit", "java");
Student s2 = new Student(112, "sumit", "java", 6000f);
s1.display();
s2.display();
}
}

8.4 this：作为参数传递给方法

this关键字也可以作为方法中的参数传递。 它主要用于事件处理。

this还是指代当前的对象。

class S2 {
void m(S2 obj) {
System.out.println("method is invoked");
}
void p() {
m(this);
}
public static void main(String args[]) {
S2 s1 = new S2();
s1.p();
}
}

this：在构造函数调用中作为参数传递

8.5 this关键字用来返回当前类的实例

可以从方法中 this 关键字作为语句返回。 在这种情况下，方法的返回类型必须是类类型(非原始)。

作为语句返回的语法

return_type method_name(){
return this;
}

Java中的继承是一种机制，表示为一个对象获取父对象的所有属性和行为。

在Java中继承是：可以创建基于现有类构建新的类。 当您从现有类继承时，就可以重复使用父类的方法和字段，也可以在继承的新类中添加新的方法和字段。

9.1 为什么在java中使用集成？

对于方法覆盖(因此可以实现运行时的多态性)，提高代码可重用性。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写(覆盖)。

Java继承的语法

class Subclass-name extends Superclass-name
{
//methods and fields
}


extends关键字表示正在从现有类派生创建的新类。 “extends”的含义是增加功能。在Java的术语中，继承的类称为父类或超类，新类称为子或子类。

9.2 继承类型

在类的基础上，在java中可以有三种类型的继承：单一，多级和分层。在Java编程中，仅能通过接口支持多重和混合继承。稍后章节中我们将了解学习接口的应用。

单一继承示例

B extends A

多级继承示例

B extends A

C extends B

分层继承示例

B extends A

C extends A

9.3 为什么在Java中不支持多重继承？

为了降低复杂性并简化语言，Java中不支持多重继承。想象一个：A，B和C是三个类。 C类继承A和B类。 如果A和B类有相同的方法，并且从子类对象调用它，A或B类的调用方法会有歧义。

实现多重继承的方式是使用接口和内部类。

如果一个类有一个类的实体引用(类中的类)，则它称为聚合。 聚合表示HAS-A关系。

何时使用聚合？

当没有is-a关系时，通过聚合也能最好地实现代码重用。

只有在所涉及的对象的整个生命周期内维持关系为is-a时，才应使用继承; 否则，聚合是最好的选择。

示例

Employee中拥有Address对象，address对象包含其自己的信息，例如城市，州，国家等。在这种情况下，关系是员工(Employee)HAS-A地址(Address)。

public class Address {
String city, province;
public Address(String city, String province) {
this.city = city;
this.province = province;
}
}
public class Emp {
int id;
String name;
Address address;
public Emp(int id, String name, Address address) {
this.id = id;
this.name = name;
this.address = address;
}
void display() {
System.out.println(id + " " + name);
System.out.println(address.city + " " + address.province);
}
public static void main(String[] args) {
Address address1 = new Address("广州", "广东");
Address address2 = new Address("海口", "海南");
Emp e = new Emp(111, "Wang", address1);
Emp e2 = new Emp(112, "Zhang", address2);
e.display();
e2.display();
}
}

如果一个类中有多个具有相同名称但参数不同的方法，则称为方法重载。如果只需要执行一个操作，具有相同的方法名称将增加程序的可读性。

方法重载的优点:

方法重载提高了程序的可读性。

重载方法不同的方式

在java中重载方法有两种方式，它们分别是：

通过改变参数的数量

通过更改数据类型

问题：为什么方法重载不能通过更改方法的返回类型？

在java中，只通过改变方法的返回类型来实现方法重载是不可能的，因为这样具有模糊性。

问题：可以重载java main()方法吗？

这是完全可以的。 可以通过方法重载在类中有任意数量的main方法。 但是JVM调用main()方法，它只接收字符串数组作为参数。

方法重载和类型提升

如果没有找到匹配的数据类型，那么会隐式地将一个类型提升到另一个类型。

void sum(int a, long b) {
System.out.println(a + b);
}
int a = 20;
int b = 20;
sum(a, 20);

这个时候由于sun(int, int不存在，jvm会将b隐式地将到另一个类型long.

如果子类中具有与父类中声明相同的方法，在java中称为方法覆盖。换句话说，如果子类提供了由其父类提供的其中一个方法的特定实现，则它被称为方法覆盖。所以方法覆盖有两个前提条件：继承和子父类中方法名称相同。

Java方法覆盖的用法:

方法重写用于提供有别于超类提供的方法的特定实现。

方法重写用于运行时多态性。 

Java方法覆盖的规则

方法必须与父类中的名称相同。

方法必须具有与父类中相同的参数。

必须是IS-A关系(继承)。

问题：可以覆盖静态方法吗？

答： 这是不可以的，静态方法不能被覆盖（这里指的是代码的执行不会存在父子之间的关系，如果在在子类中加上了静态方法是可以的，只是它和继承没有任何关系）。可以通过运行时多态来证明不能覆盖。

问题： 为什么不能覆盖静态方法？

答： 因为静态方法是绑定类，而实例方法绑定对象。 静态属于类区域，实例属于堆区域。

问题：可以重写java main方法吗？

答： 这是不可以的，因为main是一个静态方法。

java中的super关键字是一个引用变量，用于引用直接父类对象。

每当创建子类的实例时，父类的实例被隐式创建，由super关键字引用变量引用。

java super关键字的用法如下：

super可以用来引用直接父类的实例变量。

super可以用来调用直接父类方法。

super()可以用于调用直接父类构造函数。

12.1 super用于引用直接父类实例变量

可以使用super关键字来访问父类的数据成员或字段。 如果父类和子类具有相同的字段，则使用super来指定为父类数据成员或字段。

class Animal {
String color = "white";
}
class Dog extends Animal {
String color = "black";
void printColor() {
System.out.println(color);// prints color of Dog class
System.out.println(super.color);// prints color of Animal class
}
}
class TestSuper1 {
public static void main(String args[]) {
Dog d = new Dog();
d.printColor();
}
}

12.2 通过 super 来调用父类方法

super关键字也可以用于调用父类方法。 如果子类包含与父类相同的方法，则应使用super关键字指定父类的方法。 换句话说，如果方法被覆盖就可以使用 super 关键字来指定父类方法。

12.3 使用 super 来调用父类构造函数

super关键字也可以用于调用父类构造函数。

class Animal {
Animal() {
System.out.println("animal is created here");
}
}
class Dog extends Animal {
Dog() {
super();
System.out.println("dog is created here");
}
}
class TestSuper3 {
public static void main(String args[]) {
Dog d = new Dog();
}
}
console:
animal is created here
dog is created here


如果没有构造函数，编译器会自动提供默认构造函数。 但是，它还添加了super()作为第一个语句。

下面的代码用于测试：

class Animal {
Animal() {
System.out.println("animal is created");
}
}
class Dog extends Animal {
Dog() {
System.out.println("dog is created");
}
}
class TestSuper4 {
public static void main(String args[]) {
Dog d = new Dog();
}
}
console:
animal is created
dog is created

实例初始化程序块用于初始化实例数据成员。 它在每次创建类的对象时运行。实例变量的初始化可以是直接的，但是可以在初始化实例初始化块中的实例变量时执行额外的操作。

在Java中有三个地方可以执行实例初始化块操作：

方法(调用需要显示的调用)

构造函数

代码块

主要看一下实例初始化块或构造函数哪个先调用？

class Bike8 {
int speed;
Bike8() {
System.out.println("constructor is invoked");
}
{
System.out.println("instance initializer block invoked");
}
public static void main(String args[]) {
Bike8 b1 = new Bike8();
}
}


执行上面代码得到以下结果 &＃8211;

instance initializer block invoked

constructor is invoked

在上面的例子中，似乎首先调用实例初始化块，但是可惜不是。 实例初始化块在对象创建时被调用。 java编译器在第一个语句super()之后的构造函数中复制实例初始化块。 首先，调用构造函数。

如这样：

class Bike8 {
int speed;
Bike8() {
super();
System.out.println("instance initializer block invoked");
System.out.println("constructor is invoked");
}
{
System.out.println("instance initializer block invoked");
}
public static void main(String args[]) {
Bike8 b1 = new Bike8();
}
}


实例初始化块的规则：

在创建类的实例时创建实例初始化程序块。

在父类构造函数被调用之后(即在super()构造函数调用之后)调用实例初始化块。

实例初始化程序块按它们显示的顺序排列。

  编译时能得到明确值的时候，final等同于C#的const；编译时无法得到明确值的时候，final等同于C#的readonly

java中的final关键字用于限制用户修改变量或重写一个类或方法。 java final关键字可以在许多上下文中使用。

 final可以是：
变量
方法
类

final关键字可以应用于变量，没有值的final变量称为空白变量或未初始化的最终变量。 它只能在构造函数中初始化。 空白最终变量也可以是静态的，它将仅在静态块中初始化。 在之后的文章中我们将详细学习这些。

14.1 Java final变量

如果将变量设置为final，则不能更改final变量的值(它将是常量)。final关键字应用有以下几点需要注意：

禁止变量的值被改变；

禁止方法重写；

禁止类继承；

要改变final变量的值，这是不可能的，因为一个final变量一次分配一个值永远不能更改。

14.2 Java final方法

如果任何方法声明为final，则不能覆盖它。

final方法的示例，下面方法是不能覆盖的

class Bike {
final void run() {
System.out.println("running");
}
}
class Honda extends Bike {
void run() { // final方法,不可以重写
System.out.println("running safely with 100kmph");
}
public static void main(String args[]) {
Honda hOnda= new Honda();
honda.run();
}
}

14.3 Java final类

如果把任何一个类声明为final，则不能扩展它。

final class Bike {
}
class Honda1 extends Bike { // 不可以扩展 final 类
void run() {
System.out.println("running safely with 100kmph");
}
public static void main(String args[]) {
Honda1 hOnda= new Honda();
honda.run();
}
}

是否可继承final方法？

是的，final方法是继承的，但是不能覆盖它。

什么是空白或未初始化的final变量？

在声明时未初始化的final变量称为空白final变量。如果要在创建一个对象时初始化变量，并且变量在初始化后就不会被改变， 这是非常有用的。 例如员工的PAN CARD号码。它只能在构造函数中初始化。

可以初始化空白的final变量吗？

是的，但只能在构造函数中。

什么是final参数？

如果将任何参数声明为final，则不能更改它的值。

class Bike11 {
int cube(final int n) {
n = n + 2;// can't be changed as n is final
// n*n*n; // 不能修改 n 的值
return n;
}
public static void main(String args[]) {
Bike11 b = new Bike11();
b.cube(5);
}
}

14.4 静态空白final变量

在声明时未初始化的静态final变量称为静态空白final变量。 它只能在静态块中初始化。或者直接对final进行赋值。

class A {
static final int data;// static blank final variable
static {
data = 50;
}
public static void main(String args[]) {
System.out.println(A.data);
}
}


Java中的多态是一个概念，通过它我们可以通过不同的方式执行单个动作(方法)。 
多态表示为多种形式。
在Java中有两种类型的多态性：编译时多态性和运行时多态性。 我们可以通过方法重载和方法覆盖在java中执行多态性。

15.1 编译时多态

方法重载都是编译时多态。根据实际参数的数据类型、个数和次序，Java在编译时能够确定执行重载方法中的哪一个。

public class Test {
public static void main(String[] args) {
Person p = new Person(); //对象引用本类实例
Man m = new Man(); //编译时多态，执行Person类的toString()
System.out.println(p.toString());
System.out.println(m.toString()); //编译时多态，执行Man类的toString()
}
}
class Person{
public String toString() {
String name = "Person";
return name;
}
}
class Man extends Person{
public String toString(){
String name = "Man";
return name;
}
}

15.2 运行时多态

运行时多态性或动态方法分派是一个过程，它对重写方法的调用在运行时体现而不是编译时。

在此过程中，通过超类的引用变量调用重写的方法。 要调用的方法基于引用的对象。

向上转换

当父类的引用变量引用子类的对象时，称为向上转换。 例如：

class A{}  

class B extends A{}  

A a=new B();  //向上转换&＃8230;

Java运行时多态性示例

class Bike {
void run() {
System.out.println("running");
}
}
class Splender extends Bike {
void run() {
System.out.println("running safely with 60km");
}
public static void main(String args[]) {
Bike b = new Splender();// upcasting - 向上转换
b.run();
}
}


Bike和Splendar。 Splendar类扩展Bike类并覆盖其run()方法。通过父类(Bike)的引用变量调用run方法。 因为它引用子类对象，并且子类方法覆盖父类方法，子类方法在运行时被调用。

**因为方法调用是由JVM不是编译器决定的，所以它被称为运行时多态性。

 程序运行时，Java从实例所属的类开始寻找匹配的方法执行，如果当前类中没有匹配的方法，则沿着继承关系逐层向上，依次在父类或各祖先类中寻找匹配方法，直到Object类。

15.3 Java运行时多态性与数据成员

运行时多态性不能由数据成员实现。

class Bike {
int speedlimit = 90;
}
class Honda3 extends Bike {
int speedlimit = 150;
public static void main(String args[]){
Bike obj=new Honda3();
System.out.println(obj.speedlimit);//90
}
}


这两个类都有一个数据成员:speedlimit，通过引用子类对象的父类的引用变量来访问数据成员。 由于我们访问的数据成员没有被重写，因此它将访问父类的数据成员。

java instanceof运算符用于测试指定对象是否是指定类型(类或子类或接口)的实例。

java中的instanceof也称为类型比较运算符，因为它将类型与实例进行比较。 它返回true或false。 如果对任何具有null值的变量应用instanceof运算符，则返回false。

在java中用abstract关键字声明的类称为抽象类。 它可以有抽象和非抽象方法(带主体的方法)。必须将所有的方法全部实现。

Java中的抽象

抽象是隐藏实现细节并仅向用户显示功能的过程。

另一种方式，它只向用户显示重要的事情，并隐藏内部详细信息，例如：发送短信，只需输入文本并发送消息。您也不需要知道有关邮件传递的内部处理过程。

抽象可以让你专注于对象做什么(实现的功能)，而不是它如何做。

java中的接口是类的蓝图。 它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。 接口中只有抽象方法而不是方法体。接口用于在Java中实现抽象和多重继承。

Java接口也表示IS-A关系。它不能像抽象类一样被实例化。

在java中有两种实现抽象的方法，它们分别是：

抽象类(部分)

接口 (完全)

17.1 Java中的抽象类

使用 abstract关键字声明的类被称为抽象类。需要扩展和实现它的方法。 它不能被实例化。

abstract class Bank {
abstract int getRateOfInterest();
}
class SBI extends Bank {
int getRateOfInterest() {
return 7;
}
}
class PNB extends Bank {
int getRateOfInterest() {
return 8;
}
}
class TestBank {
public static void main(String args[]) {
Bank b;
b = new SBI();
System.out.println("Rate of Interest is: " + b.getRateOfInterest() + " %");
b = new PNB();
System.out.println("Rate of Interest is: " + b.getRateOfInterest() + " %");
}
}


17.2 具有构造函数，数据成员，方法等的抽象类

抽象类可以有数据成员，抽象方法，方法体，构造函数甚至main()方法

//example of abstract class that have method body
abstract class Bike {
int number = 0;
Bike() {
System.out.println("bike is created");
}
abstract void run();
void changeGear() {
System.out.println("gear changed");
}
}
class Honda extends Bike {
void run() {
System.out.println("running safely..");
}
}
class TestAbstraction2 {
public static void main(String args[]) {
Bike obj = new Honda();
obj.run();
obj.changeGear();
}
}

**规则：如果在类中有任何抽象方法，那个类必须声明为抽象的。

java中的接口是类的蓝图。 它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。 所有的抽象方法在非抽象子类中必须全部实现。接口中只有抽象方法而不是方法体。接口用于在Java中实现抽象和多重继承。Java接口也表示IS-A关系。它能像抽象类一样不能被实例化。

需要使用接口主要有三个原因:

它用于实现抽象。 通过接口，可以支持多重继承的功能。 它可用于实现松耦合。

18.1 由编译器内部添加

java编译器在接口方法之前添加public和abstract关键字。还有，它在数据成员之前添加public，static和final关键字。

换句话说，接口字段默认是public，static和final，方法默认是public和abstract。

18.2 Java多继承接口

如果一个类实现了多个接口，或者一个接口扩展了多个接口，即被称为多重继承。

interface Printable {
void print();
}
interface Showable {
void show();
}
class A7 implements Printable, Showable {
public void print() {
System.out.println("Hello");
}
public void show() {
System.out.println("Welcome");
}
public static void main(String args[]) {
A7 obj = new A7();
obj.print();
obj.show();
}
}

18.3 问题：什么是标记或标记的接口？

没有成员的接口(仅定义一个空的接口)称为标记或标记接口。 例如：可序列化，可克隆，远程等。它们用于向JVM提供一些基本信息，以便JVM可以执行一些有用的操作。

//How Serializable interface is written?
public interface Serializable{
}

18.4 Java抽象类和接口的区别

抽象类
接口

抽象类可以有抽象和非抽象方法。
接口只能有抽象方法。 从Java 8开始，它也可以有默认和静态方法。

抽象类不支持多重继承。
接口支持多继承。

抽象类可以有final，非final，静态和非静态变量。
        接口只有静态和final变量。

抽象类可以提供接口的实现。
接口不能提供抽象类的实现。

abstract关键字用来声明抽象类。
interface关键字用于声明接口。

简单地说，抽象类实现了部分抽象(0到100％)，而接口实现了完全抽象(100％)。

一个java包是一组相似类型的类，接口和子包。java中的包可以分为两种形式，内置包和用户定义包。

java中有很多内置的包，如：java，lang，awt，javax，swing，net，io，util，sql等。

Java包的优点

Java包用于对类和接口进行分类，以便更好地维护它们。
Java包提供访问保护。
Java包消除命名冲突。

如何从一个包中访问另一个包？

有三种方法从包外部来访问一个包:

import package.*;
import package.classname;
完全限定名

使用 packagename.*

import com.a.*;

使用packagename.classname

import com.a.A;

使用完全限定名

pack.A obj = new pack.A();

java中有两种类型的修饰符：访问修饰符和非修饰符。

java中的访问修饰符指定数据成员，方法，构造函数或类的辅助功能(范围)。

一共有4种类型的java访问修饰符：

private

私有(private)访问修饰符只能在类中访问。

private访问修饰符

如果将类的构造函数声明为私有，则不能从类外部创建该类的实例，如果直接设置类的访问修饰符为private，类不能是私有或保护，除非是嵌套类。

只有将类的构造函数设置为private

class A {

    private A() {

    }// private constructor

    void msg() {

        System.out.println(&＃8220;Hello java&＃8221;);

    }

}

public class Simple {

    public static void main(String args[]) {

        A obj = new A();// Compile Time Error

    }

}

default

如果不使用任何修饰符，默认情况下将其视为default修饰符。default修饰符只能在包内访问。

protected

protected访问修饰符可以在包中和包外部访问，但只能通过继承。protected访问修饰符可以应用于数据成员，方法和构造函数。 它不能应用于类。

public

公共(public)访问修饰符可随处访问。 它在所有其他修饰符中具有最广泛的范围。

访问修饰符
在类内
在包内
外部包只通过子类
外部包

Private
Y
N
N
N

Default
Y
Y
N
N

Protected
Y
Y
Y
Y              
N

Public
Y
Y
Y
Y

**如果你要覆盖任何方法，重写的方法(即在子类中声明)则不能声明得更严格。
默认(default)修饰符比受保护的修饰符更严格

java中的封装是将代码和数据一起封装到单个单元中的过程

我们可以通过将类的所有数据成员设为private，以在java中创建一个完全封装的类。现在我们可以使用setter和getter方法来设置和获取其中的数据。

Java Bean类是完全封装类的示例。

在java中封装的优势

通过仅提供setter或getter方法，可以使类为只读或只写。

它为您提供对数据的控制。 假设要设置id的值，即：要求大于100，您可以在setter方法内写入逻辑。

public class A {
private String name;

public void setName(String name) {
this.name = name;
}

public void msg() {
System.out.println("Hello");
}

public String getName() {
return name;
}
}

默认情况下，Object类是java中所有类的父类。 换句话说，它是java的顶级类。

方法
     描述

public final Class getClass()
     返回此对象的Class类对象。 Class类可以进一步用于获取此类的元数据。

public int hashCode()
     返回此对象的哈希码值

public boolean equals(Object obj)
     将给定对象与此对象进行比较。

protected Object clone() throws CloneNotSupportedException
     创建并返回此对象的精确副本(克隆)。

public String toString()
     返回此对象的字符串表示形式。

public final void notify()
             唤醒单线程，等待此对象的监视器。

public final void notifyAll()
     唤醒所有线程，等待此对象的监视器。

public final void wait(long timeout)throws InterruptedException
     导致当前线程等待指定的毫秒，直到另一个线程通知(调用notify()或notifyAll()方法)。

public final void wait(long timeout,int nanos)throws InterruptedException
             导致当前线程等待指定的毫秒和纳秒，直到另一个线程通知(调用notify()或notifyAll()方法)。

public final void wait()throws InterruptedException
     导致当前线程等待，直到另一个线程通知(调用notify()或notifyAll()方法)。

protected void finalize()throws Throwable
             在对象被垃圾收集之前由垃圾收集器调用。

对象克隆是一种创建对象的精确副本的方法。 Object类的clone()方法用于克隆对象。java.lang.Cloneable接口必须由我们要创建其对象克隆的类实现。如果我们不实现Cloneable接口，clone()方法生成CloneNotSupportedException。

clone()方法在Object类中定义。 clone()方法的语法如下：

protected Object clone() throws CloneNotSupportedException

为什么要使用clone()方法？

clone()方法保存用于创建对象的精确副本的额外处理任务。 如果我们使用new关键字执行它，它将需要执行大量的处理，这就是为什么我们使用对象克隆。

对象克隆的优点：少处理任务。

自J2SE 5.0以来，自动装箱和取消装箱功能将原始对象和对象自动转换为原始数据类型。将原始数据类型自动转换为对象称为自动装箱，反之亦然。

java.lang包的八个类在java中称为包装类。八个包装类的列表如下：

基本类型
包装类

boolean
Boolean

char
Character

byte
Byte

short
Short

int
Integer

long
Long

float

Float

double
Double

编号
对象
类

1
对象是类的一个实例。
类是创建对象的蓝图或模板。

2
对象是真实世界的实体，如笔，笔记本电脑，手机，床，键盘，鼠标，椅子等。
类是一组类似的对象。

3
对象是一个物理实体。
类是一个逻辑实体。

4
对象主要通过new关键字创建，例如：Student s1=new Student();
类使用class关键字，如：class Student {}

5
对象根据需要可创建多次。
类只声明一次。

6
对象在创建时分配内存。
类在创建时不需要分配内存。

7
new关键字，newInstance()方法，clone()方法，工厂方法和反序列化。
在java中只有一种方法：使用class关键字来定义类。

编号
方法重载
方法重写

1
方法重载用于提高程序的可读性。
方法重写用于提供已经由其超类提供的方法的特定实现。

2
方法重载在类内执行。
方法重写发生在具有IS-A(继承)关系的两个类中。

3
在方法重载的情况下，
参数必须不同。
在方法重写的情况下，参数必须相同。

4
方法重载是编译时多态性的例子。
方法重写/覆盖是运行时多态性的例子。

5
在java中，方法重载不能仅通过改变方法的返回类型来执行。
在方法重写/覆盖中返回类型必须相同或协变。