JavaSE（基础篇）——面向对象（万字总结）

那么对main方法中的以下代码:

Student s = new Student();

1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋值)

2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)

例如:显式赋值

private String name = "tom";

3)调用构造器

4)把对象内存地址值赋值给变量。(=号赋值操作)

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

1.必须和类的名字相同。

2.不能有返回类型，也不能写void

构造器的作用

1.使用new创建对象的时候必须使用类的构造器.

2.构造器中的代码执行后,可以给对象中的属性初始化赋值.

【演示】

public class Student{
   privacy String name ;
   
   public Student(){
     this.name = "铁甲小宝";
  } 
}

构造器重载

有时候我们不仅仅是无参构造，我们也可以使用有参构造器，在创建对象时候可以给属性赋值.

【演示】

public class Student{
   privacy String name ;
   
   public Student(){
     this.name = "铁甲小宝";
  } 
   
  public Student(String name ){
      this.name = name;
  }
}

构造器之间的调用

使用this关键字可以在一个构造器中调用另外一个构造器的代码。

注意：this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键字才会创建新对象。

public class Student{
   privacy String name ;
   
   public Student(){
     this();
  } 
   
  public Student(String name ){
      this.name = name;
  }
}

默认构造器

在Java中如果我们没有写构造器的话，那么在编译的时候也会构造出来一个无参构造器，这个无参构造器被称为默认构造器

【演示】

public class Student{

 }
main:
//编译通过,因为有无参构造器 
Student s = new Student();

如果我们写了一个构造器，在编译后就不会在构造出来一个构造器。

【演示】

public class Student{ 
private String name; 
public Student(String name){ 
    this.name = name;
 } 
}
main: 
//编译报错,因为没有无参构造器 
Student s = new Student();

封装

如果我们想看电视，我们需要去了解电视里面的二极管的构造吗？当然不是，我们只需要拿到开关，按下开关键就可以。

电视制造商为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口。

就比如开关。

白话说就是：该露的露，该藏的藏。

专业术语：我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允外部干涉。低耦合：仅暴露少量的方法给外部使用。

封装（隐藏的数据）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

封装的步骤

1.需要使用private来修饰需要封装的变量。

2.提供一个公开的方法设置或者访问私有属性

设置通过set方法，命名格式： set属性名（）; 属性的首字母要大写

访问通过get方法，命名格式： get属性名（）; 属性的首字母要大写

【演示】

//对象能在类的外部"直接"访问 
public class Student{ 
public String name; 
public void println(){ 
System.out.println(this.name);
 } 
}
public class Test{ 
public static void main(String[] args){ 
Student s = new Student(); 
s.name = "tom";
 } 
}

在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来。

【演示】

public class Student{ 
private String name;
 }
public class Test{ 
public static void main(String[] args){ 
Student s = new Student();
//编译报错,在类的外部不能直接访问类中的私有成员 
s.name = "tom";
 } 
}

如果在类的外部需要访问这些私有属性 , 那么可以在类中提供对于的 get 和 set 方法 , 以便让用户在类的外部可以间接的访问到私有属性。

//set负责给属性赋值 
//get负责返回属性的值 
public class Student{ 
private String name; 
public void setName(String name){ 
this.name = name;
 }
public String getName(){ 
return this.name;
 } 
}
public class Test{ 
public static void main(String[] args){
Student s = new Student();
s.setName("tom");
System.out.println(s.getName());
  }
}

作用和意义

1.提高程序的安全性，保护数据。

2.隐藏代码的实现细节。

3.同一用户的调用接口。

4.提高系统的可维护性。

5.便于调用者调用。

良好的封装，便于修改内部代码，提高可维护性。

良好的封装，可进行数据完整性检测，保证数据的有效性。

方法的重载

一般类中有多个方法，但是也有很多方法重名，但是参数类型不同，这种情况就叫做方法的重载，方法的重载可以提高调用方法的灵活性。

【演示：println的方法重载】

public class Test{ 
public void test(String str){
 }
public void test(int a){
 } 
}

方法的重载必须满足一下条件：

1.满足方法名称相同。

2.方法的参数列表类型不同。

3.方法返回值可以相同也可以不同。

在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表

下面是我自己写的一个小例子，大家可以看看嘿嘿嘿嘿。

继承

现实世界中继承无处不在。

比如动物可以分为哺乳动物，爬行动物等。

而哺乳动物还可以在继续分为：灵长动物，鲸等。

继承的本质事对某一批的抽象，和对现实世界的更好建模。

为什么需要继承？

继承的好处是什么？

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。

第二好处：为了提高代码的复用性。

extands 的意思是 “ 扩展 ” 。子类是父类的扩展。

【注】JAVA中类只有单继承，没有多继承！接口可以多继承！

继承

1.继承事类和类之间的关系，除了继承还有组合，依赖，聚合等。

2.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

public class student extends Person{ 
}

3.子类和父类之间,从意义上讲应该具有"is a"的关系。

4.类和类之间的继承是单继承。

一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲

一个父类可以被多子类继承,就像一个父亲可以有多个孩子

注:java中接口和接口之间,有可以继承,并且是多继承。

5.父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方

法原有的修饰符(public protected default private)相关的。

例如 :

父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用

父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用

Object类

Java中每一个类都是直接或间接的继承了Object这个类。

System.out.println(任何对象 instanceof Object); 
//输出结果:true 
//注:任何对象也包含数组对象 
例如: 
//编译后,Person类会默认继承Object 
public class Person{
} 
//Student是间接的继承了Object 
public class Student extends Person{
}

在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法（因为Object是所以类的父类）

例如:toString方法、equals方法、getClass方法等。

注：Object类中的每一个方法之后都会使用到。

Super关键字

子类继承父类以后，在子类中可以使用this来表示或者访问或调用子类中的属性或方法，使用super可以访问或者调用父类中的属性和方法。

super的使用

【访问父类中的属性】

public class Person{ 
protected String name = "zs";
 }
public class Student extends Person{ 
private String name = "lisi"; 
public void test(String name){
 System.out.println(name);
 System.out.println(this.name);
 System.out.println(super.name);
 } 
}

【调用父类中的方法】

public class Person{
 public void print(){ 
System.out.println("Person");
 } 
}
public class Student extends Person{ 
public void print(){
 System.out.println("Student");
 }
public void test(){ 
print(); 
this.print(); 
super.print(); 
 } }

【调用父类中的构造器】

public class Person{
 }
public class Student extends Person{ 
//编译通过,子类构造器中会隐式的调用父类的无参构造器 
//super(); 
public Student(){
 } 
}

父类没有无参构造

public class Person{ 
protected String name;
public Person(String name){ 
this.name = name;
 } 
}
public class Student extends Person{ 
//编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器 
//super(); 
public Student(){
 } 
}

【显式的调用父类的有参构造器】

public class Person{ 
protected String name; 
public Person(String name){ 
this.name = name;
 } 
}
public class Student extends Person{ 
//编译通过,子类构造器中显式的调用父类的有参构造器 
public Student(){ 
super("tom");
 } 
}

注：不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

【super使用的注意的地方】

1.用super调用父类构造方法，必须是构造方法中的第一个语句。

2.super只能出现在子类的方法或者构造方法中。

3.super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）。

【super 和 this 的区别】

1.代表的事物不一样:

this ：代表所属方法的调用者对象。

super：代表父类对象的引用空间。

2.使用前提不一致：

this：在非继承的条件下也可以使用。

super：只能在继承的条件下才能使用。

3.调用构造方法：

this：调用本类的构造方法。

super：调用的父类的构造方法

方法的重写

方法的重写（override）

1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.

2.静态方法不能重写。

1. 父类的静态方法不能被子类重写为非静态方法 //编译出错

2. 父类的非静态方法不能被子类重写为静态方法；//编译出错

3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

【例子】

A类继承B类 
A和B中都一个相同的静态方法test 
B a = new A(); 
a.test();
//调用到的是B类中的静态方法test 
A a = new A(); 
a.test();
//调用到的是A类中的静态方法test 
可以看出静态方法的调用只和变量声明的类型相关 
这个和非静态方法的重写之后的效果完全不同

1. 私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。

【例子】

public class Person{ private void run(){
   } 
}
//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法 
public class Student extends Person{ 
private void run(){
}
 }

重写的语法

1.方法名必须相同。

2.参数列表必须相同。

3.访问控制修饰符可以被扩大,但是不能被缩小： public protected default private。

4.抛出异常类型的范围可以被缩小,但是不能被扩大。

ClassNotFoundException ---> Exception

5.返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型。

例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的

子类型

为什么要重写？

子类继承父类中的方法，但是父类中的方法并不满足子类的功能需求，所以子类中要把方法进行重写。

总结：

方法重写的时候，必须存在继承关系。

方法重写的时候，方法名和形式参数必须跟父类是一致的。

方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <public，friendly < public )

方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系

方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

多态

认识多态

多态是OOP（面向对象）中一个重要的特性，主要是用来实现动态联编的，换句话说就是程序的最终状态就有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。

相同类域的不同对象,调用相同的方法,执行结果是不同的：

1.一个对象的实际类型是确定的

例如：

Person s1 = new Student;
//和
Student s2 = new Student;
//是不相同的

2.可以指向对象的引用的类型有很多

一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。

例如：Student继承了Person类

Studnet s1 = new Student;
Person s2 = new Student;
Object s3 = new Student;

因为Person和Object都是Student的父类。

注：一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型

1.一个父类引用可以指向它的任何一个子类对象

例如：

Object o = new AnyClass(); 
Person p = null; 
p = new Student(); 
p = new Teacher(); 
p = new Person();

2.多态中的方法调用

例如：

public class Person{
 public void run(){
 } 
}
public class Student extends Person{
 }

3.调用到的run方法,是Student从Person继承过来的run方法

main: 
Person p = new Student(); 
p.run();

例如：

public class Person{ 
public void run(){
  }
 }
public class Student extends Person{ 
public void run(){ 
//重写run方法 
  }
 }
//调用到的run方法,是Student中重写的run方法 
main: 
Person p = new Student(); 
p.run();

注：子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法, 如果重写了,那么调用的就是重写之后的方法。

子类中独有方法的调用

public class Person{ 
public void run(){
  } 
}
public class Student extends Person{ 
public void test(){ 
  } 
}
main: 
Person p = new Student();
//调用到继承的run方法 p.run(); 
//编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编 译报错.
p.test();

注：一个变量x,调用一个方法test,编译器是否能让其编译通过,主要是看声明变量x的类型中有没有定义test方法,如果有则编译通过,如果没有则编译报错.而不是看x所指向的对象中有没有test方法.

原理：编译看左边，运行不一定看右边。

编译看左边的意思： java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。子类的成员是特有的，父类的没有的，所以他是找不到的。

子类和父类引用指向对象的区别

Student s = new Student(); 
Person p = new Student();
Object o = new Student();

变量s能调用的方法是Student中有的方法(包括继承过来的),变量p能调用的方法是Person中有的方法(包括继承过来的)。

但是变量p是父类型的,p不仅可以指向Student对象,还可以指向Teacher类型对象等,但是变量s只能指Studnet类型对象,及Student子类型对象。变量p能指向对象的范围是比变量s大的。

Object类型的变量o,能指向所有对象,它的范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法,因为变量o声明的类型就是Object.

注：：java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。

重写，重载和多态的关系

重载是编译时多态

调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错。

重写是运行时多态

调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用, 是运行时动态和对象绑定的)

多态的注意事项

1.多态是方法的多态，属性没有多态性。

2.编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。比如：本来是狗，我把它转成猫。就会报这个异常。

3.多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象。

多态存在的条件

1.有继承关系

2.子类重写父类方法

3.父类引用指向子类对象

补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：

1.static方法，因为被static修饰的方法是属于类的，而不是属于实例的。

2.fifinal方法，因为被fifinal修饰的方法无法被子类重写。

3.private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢。

方法绑定

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。

静态绑定

在编译期完成，可以提高代码执行速度。

动态绑定

通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了fifinal类、fifinal方、static方法，所有方法都是JVM在运行期才进行动态绑定的。

多态：如果编译时类型和运行时类型不一致，就会造成多态。

instanceof和类型转换

instanceof

public class Person{ public void run(){
} }
public class Student extends Person{
 }
public class Teacher extends Person{
 }

main:
Object o = new Student(); 
System.out.println(o instanceof Student);//true 
System.out.println(o instanceof Person);//true 
System.out.println(o instanceof Object);//true 
System.out.println(o instanceof Teacher);//false 
System.out.println(o instanceof String);//false 
\--------------------------- 
Person o = new Student(); 
System.out.println(o instanceof Student);//true 
System.out.println(o instanceof Person);//true 
System.out.println(o instanceof Object);//true 
System.out.println(o instanceof Teacher);//false 
//编译报错 
System.out.println(o instanceof String); 
\--------------------------- 
Student o = new Student(); 
System.out.println(o instanceof Student);//true 
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true 
//编译报错 
System.out.println(o instanceof Teacher); 
//编译报错 
System.out.println(o instanceof String);

【分析1】

System.out.println(x instanceof Y);

该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有"子父类关"系就编译通过, 没有子父类关系就是编译报错.

之后学习到的接口类型和这个是有点区别的。

【分析2】

System.out.println(x instanceof Y);

输出结果是true还是false,主要是看变量x所指向的对象实际类型是不是Y类型的"子类型".

main: 
Object o = new Person(); 
System.out.println(o instanceof Student);//false 
System.out.println(o instanceof Person);//true 
System.out.println(o instanceof Object);//true 
System.out.println(o instanceof Teacher);//false 
System.out.println(o instanceof String);//false

类型转换

public class Person{ public void run(){
 } 
}
public class Student extends Person{
 public void go(){
 } 
}
public class Teacher extends Person{ 
}

【为什么要类型转换】

//编译报错,因为p声明的类型Person中没有go方法 
Person p = new Student(); 
p.go(); 
//需要把变量p的类型进行转换 
Person p = new Student(); 
Student s = (Student)p; 
s.go(); 
或者//注意这种形式前面必须要俩个小括号 
((Student)p).go();

【类型转换中的问题】

//编译通过 运行没问题 
Object o = new Student(); 
Person p = (Person)o; 
//编译通过 运行没问题
Object o = new Student(); 
Student s = (Student)o; //编译通过,运行报错 Object o = new Teacher(); Student s = (Student)o; 
即: X x = (X)o; 
运行是否报错,主要是变量o所指向的对象实现类型,是不是X类型的子类型,如果不是则运行就会报错。

【总结】

1.父类引用可以指向子类对象，子类引用不能指向父类对象。

2.把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。如Father father = new Son();

3.把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。

如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son） father；

其中father前面的（Son）必须添加，进行强制转换。

4.upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效。

5.向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

修饰符

static修饰符

1.static变量

在类中，使用static修饰的成员变量,就是静态变量,反之为非静态变量。

静态变量和非静态变量的区别

静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.

public class Student{ 
private static int age; 
private double score; 
public static void main(String[] args) { 
Student s = new Student(); 
//推荐使用类名访问静态成员 
System.out.println(Student.age); 
System.out.println(s.age); 
System.out.println(s.score);
 } 
}

静态变量对于类而言在内存中只有一个,能被类的所有实例所共享。实例变量对于类的每个实例都有一份, 它们之间互不影响.

public class Student{ 
private static int count;
private int num; 
public Student() { 
count++; 
num++;
 }
public static void main(String[] args) { 
Student s1 = new Student(); 
Student s2 = new Student(); 
Student s3 = new Student(); 
Student s4 = new Student(); 
//因为还是在类中,所以可以直接访问私有属性 
System.out.println(s1.num); 
System.out.println(s2.num); 
System.out.println(s3.num); 
System.out.println(s4.num); 
System.out.println(Student.count); 
System.out.println(s1.count); 
System.out.println(s2.count); 
System.out.println(s3.count); 
System.out.println(s4.count); 
 } 
}

在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存，所以静态变量可以使用类名来直接访问,而不需要使用对象来访问。

2.static方法

在类中，使用static修饰的成员方法,就是静态方法,反之为非静态方法。

静态方法和非静态方法的区别

静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.

静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态方法。

注意：:this和super在类中属于非静态的变量.(静态方法中不能使用)

public class Student{ 
private static int count; 
private int num; 
public void run(){
} 
public static void go(){
} 
public static void test(){ 
//编译通过 
System.out.println(count); 
go(); 
//编译报错 
System.out.println(num); 
run(); 
 }
}

非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方法。

public class Student{ 
private static int count; 
private int num; 
public void run(){
} 
public static void go(){
} 
public void test(){ 
//编译通过 
System.out.println(count); 
go(); 
//编译通过 
System.out.println(num); 
run();
 } 
}

思考：为什么静态方法和非静态方法不能直接相互访问? 加载顺序的问题！

父类的静态方法可以被子类继承,但是不能被子类重写。

public class Person { 
public static void method() {
} 
}
//编译报错 
public class Student extends Person { 
public void method(){
 } 
}
例如: 
public class Person { 
public static void test() { 
System.out.println("Person");
 } 
}
//编译通过,但不是重写 
public class Student extends Person { 
public static void test(){ 
System.out.println("Student");
 } 
}
main: 
Perosn p = new Student(); 
p.test();
//输出Person 
p = new Person(); 
p.test();
//输出Perosn
和非静态方法重写后的效果不一样

父类的非静态方法不能被子类重写为静态方法；

public class Person { 
public void test() { 
System.out.println("Person");
 } 
}
//编译报错 
public class Student extends Person { 
public static void test(){ 
System.out.println("Student");
 } 
}

3.代码块和静态代码块

【类中可以编写代码块和静态代码块】

public class Person {
 { 
//代码块(匿名代码块)
 }
static{
 //静态代码块
 } 
}

【匿名代码块和静态代码块的执行】

因为没有名字,在程序并不能主动调用这些代码块。

匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的时候都会自动执行.

静态代码块是在类加载完成之后就自动执行,并且只执行一次。
注：:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次.

public class Person {
 { 
System.out.println("匿名代码块");
 }
static{ 
System.out.println("静态代码块");
 }
public Person(){ 
System.out.println("构造器");
 } 
}
main: 
Student s1 = new Student(); 
Student s2 = new Student(); 
Student s3 = new Student();
//输出
静态代码块 
匿名代码块 
构造器 
匿名代码块 
构造器 
匿名代码块 
构造器

【匿名代码块和静态代码块的作用】

匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。

静态代码块的作用是给类中的静态成员变量初始化赋值。

例如：

public class Person { 
public static String name;
 static{
 name = "tom";
 }
public Person(){
 name = "zs";
 }
}
main: 
System.out.println(Person.name);
//tom

注：在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静态变量可以不创建对象而直接使用类名来访问.

4.创建和初始化对象的过程

Student s = new Student();

【Student类之前没有进行类加载】

1.类加载,同时初始化类中静态的属性。

2.执行静态代码块。

3.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null) 。

4.调用Student的父类构造器。

5.对Student中的属性进行显示赋值(如果有的话)。

6.执行匿名代码块。

7.执行构造器。

8.返回内存地址。

注：子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候

public class Person{ 
private String name = "zs"; 
public Person() { 
System.out.println("Person构造器"); 
print(); 
}
public void print(){
System.out.println("Person print方法: name = "+name);
 } 
}
public class Student extends Person{ 
private String name = "tom";
 { 
System.out.println("Student匿名代码块");
 }
static{ 
System.out.println("Student静态代码块");
 }
public Student(){ 
System.out.println("Student构造器");
 }
public void print(){ 
System.out.println("student print方法: name = "+name);
 }
public static void main(String[] args) { 
new Student();
 } 
}
//输出：
Student静态代码块 
Person构造器 
student print方法: name = null 
Student匿名代码块 
Student构造器 
Student s = new Student(); 
Student类之前已经进行了类加载 
1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null) 
2.调用Student的父类构造器 
3.对Student中的属性进行显示赋值(如果有的话) 
4.执行匿名代码块 
5.执行构造器 
6.返回内存地址

5.静态导入

静态导包就是java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。

意思是导入这个类里的静态方法。

好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便。

import static java.lang.Math.random; 
import static java.lang.Math.PI; 
public class Test { 
public static void main(String[] args) { 
//之前是需要Math.random()调用的 
System.out.println(random()); 
System.out.println(PI);
 } 
}

final修饰符

1.修饰类

用final修饰的类不能被继承,没有子类。

例如：我们是无法写一个类去继承String类,然后对String类型扩展的,因为API中已经被String类定义为final的了.

我们也可以定义fifinal修饰的类:

public final class Action{
 }
//编译报错 
public class Go extends Action{
 }

2.修饰方法

用final修饰的方法可以被继承,但是不能被子类的重写。

例如：每个类都是Object类的子类,继承了Object中的众多方法,在子类中可以重写toString方法、equals方法等,但是不能重写getClass方法 wait方法等,因为这些方法都是使用fianl修饰的。

public class Person{ public final void print(){
 } 
}
//编译报错 
public class Student extends Person{
 public void print(){
 } 
}

3.修饰变量

用final修饰的变量表示常量,只能被赋一次值.其实使用fifinal修饰的变量也就成了常量了,因为值不会再变了。

【修饰局部变量】

public class Person{ 
public void print(final int a){ 
//编译报错,不能再次赋值,传参的时候已经赋过了
 a = 1;
  }
}

public class Person{ 
  public void print(){ 
  final int a; 
  a = 1;
  //编译报错,不能再次赋值 
  a = 2;
 } 
}

【修饰成员变量-非静态成员变量】

public class Person{ 
private final int a;
 }
只有一次机会,可以给此变量a赋值的位置: 
声明的同时赋值 
匿名代码块中赋值 
构造器中赋值(类中出现的所有构造器都要写)

【修饰成员变量-静态成员变量】

public class Person{ 
private static final int a;
 }
只有一次机会,可以给此变量a赋值的位置:
声明的同时赋值 
静态代码块中赋值

【修饰引用变量】

main: 
final Student s = new Student(); 
//编译通过 
s.setName("tom"); 
s.setName("zs"); 
//编译报错,不能修改引用s指向的内存地址 
s = new Student();

abstract修饰符

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

1.抽象类和抽象方法的关系

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

2.语法

public abstract class Action{ 
public abstract void doSomething();
 }
public void doSomething(){...}

对于这个普通方法来讲:

“public void doSomething()"这部分是方法的声明。

”{...}"这部分是方法的实现,如果大括号中什么都没写,就叫方法的空实现

声明类的同时 , 加上 abstract 修饰符就是抽象类。

声明方法的时候 , 加上 abstract 修饰符 , 并且去掉方法的大口号 , 同时结尾加上分号 , 该方法就是抽象方法。

3.特点及作用

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。

抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

注：子类继承抽象类后,需要实现抽象类中没有实现的抽象方法,否则这个子类也要声明为抽象类。

public abstract class Action{ 
public abstract void doSomething();
 }
main: 
//编译报错,抽象类不能new对象 
Action a = new Action();
//子类继承抽象类 
public class Eat extends Action{ 
//实现父类中没有实现的抽象方法 
public void doSomething(){ 
//code
 } 
}
main: 
Action a = new Eat(); 
a.doSomething();

注：子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

4.思考

思考1：: 抽象类不能new对象,那么抽象类中有没有构造器?

抽象类是不能被实例化,抽象类的目的就是为实现多态中的共同点,抽象类的构造器会在子类实例化时调用,因此它也是用来实现多态中的共同点构造，不建议这样使用！

思考2：抽象类和抽象方法意义(为什么要编写抽象类、抽象方法)

打个比方，要做一个游戏。如果要创建一个角色，如果反复创建类和方法会很繁琐和麻烦。建一个抽象类后。若要创建角色可直接继承抽象类中的字段和方法，而抽象类中又有抽象方法。如果一个角色有很多种职业，每个职业又有很多技能，要是依次实例这些技能方法会显得想当笨拙。定义抽象方法，在需要时继承后重写调用，可以省去很多代码。总之抽象类和抽象方法起到一个框架作用。很方便后期的调用和重写抽象方法是为了程序的可扩展性。重写抽象方法时即可实现同名方法但又非同目的的要求。

接口

1.接口的本质

普通类：只有具体实现。

抽象类：具体实现和规范(抽象方法) 都有！

接口：只有规范！

【为什么需要接口?接口和抽象类的区别?】

1.接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

2.抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。

3.从接口的实现者角度看，接口定义了可以向外部提供的服务。

4.从接口的调用者角度看，接口定义了实现者能提供那些服务。

5.接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

【接口的本质探讨】

1.接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

2.接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

3.OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

2.接口与抽象类的区别

抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。

声明类的关键字是class,声明接口的关键字是interface。

抽象类是用来被继承的,java中的类是单继承。

类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态。

一个父类的引用,可以指向这个父类的任意子类对象。

注：继承的关键字是extends

接口是用来被类实现的,java中的接口可以被多实现。

类A实现接口B、C、D、E..,那么类A的对象就属于B、C、D、E等类型了,可以使用多态。

一个接口的引用,可以指向这个接口的任意实现类对象。

注：:实现的关键字是implements

3.接口中的方法都是抽象方法

接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法。

public interface Action{ 
public abstract void run(); 
//默认就是public abstract修饰的 
void test(); 
public void go();
 }

4.接口中的变量都是静态常量(public static fifinal修饰)

接口中可以不写任何属性,但如果写属性了,该属性必须是public static fifinal修饰的静态常量。

注：可以直接使用接口名访问其属性。因为是public static修饰的。

注：声明的同时就必须赋值.(因为接口中不能编写静态代码块)。

public interface Action{ 
public static final String NAME = "tom"; 
//默认就是public static final修饰的 
int AGE = 20; }
main: 
System.out.println(Action.NAME); 
System.out.println(Action.AGE);

5.一个一个类可以实现多个接口

public class Student implements A,B,C,D{ 
//Student需要实现接口A B C D中所有的抽象方法 
//否则Student类就要声明为抽象类,因为有抽象方法没实现 
}
main: 
A s1 = new Student(); 
B s2 = new Student(); 
C s3 = new Student(); 
D s4 = new Student();

注：

s1只能调用接口A中声明的方法以及Object中的方法.

s2只能调用接口B中声明的方法以及Object中的方法 .

s3只能调用接口C中声明的方法以及Object中的方法 .

s4只能调用接口D中声明的方法以及Object中的方法.

注：必要时可以类型强制转换。

例如：接口A 中有test() ，接口B 中有run()

A s1 = new Student(); 
s1.test(); 
B s2 = new Student(); 
s2.run(); 
if(s1 instanceof B){
 ((B)s1).run();
 }

6.一个接口可以继承多个父接口

public interface A{ 
public void testA();
 }
public interface B{ 
public void testB();
 }
//接口C把接口A B中的方法都继承过来了
public interface C extends A,B{ 
public void testC();
 }
//Student相当于实现了A B C三个接口,需要实现所有的抽象方法 
//Student的对象也就同时属于A类型 B类型 C类型 
public class Student implements C{ 
public viod testA(){
}
public viod testB(){
} 
public viod testC(){
 } 
}
main: 
C o = new Student(); 
System.out.println(o instanceof A);//true 
System.out.println(o instanceof B);//true 
System.out.println(o instanceof C);//true 
System.out.println(o instanceof Student);//true 
System.out.println(o instanceof Object);//true 
System.out.println(o instanceof Teacher);//false 
//编译报错 
System.out.println(o instanceof String);

注：System.out.println(o instanceof X);

如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译,至于其结果是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。

注：一个引用所指向的对象,是有可能实现任何一个接口的。(java中的多实现) 。

7.接口的作用

接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建。

【接口名】【对象名】= new 【实现接口的类】

这样你想用哪个类的对象就可以new哪个对象了，不需要改原来的代码。

假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，new b（）就是用b的方法。

这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同。

【总结】

1.Java接口中的成员变量默认都是public,static,fifinal类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)。

2.Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化。

3.Java接口中只能包含public,static,fifinal类型的成员变量和public,abstract类型的成员方法。

4.接口中没有构造方法,不能被实例化。

5.一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口。

6.Java接口必须通过类来实现它的抽象方法。

7.当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类。

8.不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例。

9.一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承。

【实例】

interface SwimInterface{ 
void swim();
 }
class Fish{ 
int fins=4;
 }
class Duck { 
int leg=2; 
void egg(){};
 }
class Goldfish extends Fish implements SwimInterface { 
@Override public void swim() { 
System.out.println("Goldfish can swim ");
 } 
}
class SmallDuck extends Duck implements SwimInterface { 
public void egg(){ 
System.out.println("SmallDuck can lay eggs ");
 }
@Override public void swim() { 
System.out.println("SmallDuck can swim ");
 } 
}
public class InterfaceDemo { 
public static void main(String[] args) { 
Goldfish goldfish=new Goldfish();
goldfish.swim();
SmallDuck smallDuck= new SmallDuck(); 
smallDuck.swim(); 
smallDuck.egg();
 } 
}

写了一个星期可算写完了，泪目呜呜呜呜呜。