面向对象

面向对象：以类的方式组织代码 
  
  
  
  
  
  
，以对象组织数据

特性：

封装 继承 多态

类：抽象概念

对象：具体事物

面向对象是java学习的重中之重
  
  
  
  
  
  
 ，毕竟java就是一个面向对象的语言~ 类 = 属性+方法 面向对象的概念适合复杂系统 
  
  
  
  
  
  
、多人协作 从宏观上来说
 


 


 


 


 


 


 ，java是面向对象的 
 
 
 
 
 
 
，但在微观上是面向过程的

创建

对象的创建

使用new实例化一个对象
   
   
   
   
   
   
 ，如

Student student = new Student();//实例化对象

new时：

内存空间的分配 属性的初始化 构造器的调用 返回一个对象的引用（指针）

构造器

构造器在实例化时首先被自动调用
 

 

 

 

 

 

 ，用于初始化参数             。

new的本质是调用了构造器 

 

 

 

 

 

 
，返回一个对象

名字和类名相同

没有返回类型（不能写！）

可以传参

this是一个指针             ，指向这个对象本身

public class Person { String name; public Person(){ //构造器 this.name = "小明"; } }

封装--访问控制

“高耦合

 
 

 
 

 
 

 
 

 
 

 
 

 ，低内聚 
  
  
  
  
  
  
”












，内部数据操作细节自己完成                    ，不由外部干涉
 
 
 
 
 
 
 
 
 
 
 
 
 ， 暴露少部分方法给外部使用 
  
 
  
 
  
 
  
 
  
 
  
 
 。

封装：禁止访问对象的实际表示



















，而应该通过接口来访问













。

修饰词：

public:可以由外部调用             ，公开使用 private:不可由外部调用 protected：由本包内或不同包的子类调用

继承

使用extend关键字
  
 
  
 
  
 
  
 
  
 
  
 
  ，表示子类是父类的扩展

public class Student extends Person{ Student(String name){ this.name = name; } } 子类拥有父类的全部public/protected方法和属性 且子类可以对所有方法和属性重写 private属性无法被继承 java中所有类都是object类的子类

构造器

使用super可以访问到父类












，构造器中super.generator()可以调用父类的构造器 
  
  
  
  
  
  。

public class Person { String name; public Person(String name){ //构造器 this.name = name; } } public class Student extends Person{ Student(String name){ super(name); } } public class Demo2 { public static void main(String[] args){ Student s = new Student("小明"); System.out.println(s.name); } }

输出“小明
  
  
  
  
  
  
 ” 
  
  
  
  
  
  
 。

如果在子类中不指定调用super 
  
  
  
  
  
  
，会自动调用

public class Person { String name; public Person() { //构造器 System.out.println("父类Person无参数构造器执行"); } } public class Student extends Person{ Student(){ System.out.println("子类Student无参数构造器执行"); } }

在new Student时输出：

若将子类构造器改为有参
  
  
  
  
  
  
 ，仍然会首先调用父类的无参构造器

大致逻辑如下：

注：

调用构造器时
 


 


 


 


 


 


 ，需要将父类构造器调用语句放在子类构造器的第一句 父类没写无参 
 
 
 
 
 
 
，默认有一个空的构造器函数 如果写了一个有参构造器
   
   
   
   
   
   
 ，那么父类就没有无参构造器了
 

 

 

 

 

 

 ，子类不能自动调用构造器 

 

 

 

 

 

 
，即子类中必须显式调用有参构造器了

 


 


 


 


 


 


。

方法重写

Person类: public static void test(){ System.out.println("Person Test"); }

Student类：

public static void test(){ System.out.println("Student Test"); }

调用：

public static void main(String[] args){ Student s = new Student("小明"); s.test(); }

结果：

但是             ，如果修改main public static void main(String[] args){ Person s = new Student("小明"); s.test(); }

会导致输出：

这可以说明

调用的方法根据声明的类型确定

以上结论来自于静态方法

如果全部改为非静态

 
 

 
 

 
 

 
 

 
 

 
 

 ，即将test改为无static修饰

如

@Override public void test(){ System.out.println("Student Test"); }

注意点：

override 的前提是继承 方法名相同 参数列表相同（不是重载） 修饰符的范围只能扩大不能缩小 public>protected>default>private 异常的范围可以被缩小但不能扩大,如：ClassNotFoundException->Exception

多态

定义

同一方法根据对象的不同采用不同的行为

引用类型

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












，但引用类型并不一致

如

Student s = new Student(); Person s1 = new Student(); Object s2 = new Student();

实际类型都是Student                    ，而引用类型可以是其任意父类

对于这样的对象s1/s2
 
 
 
 
 
 
 
 
 
 
 
 
 ，如果没有static修饰



















，调用一个方法时

若子类父类都有该方法             ，且子类未重写：调用父类的方法

若都有
  
 
  
 
  
 
  
 
  
 
  
 
  ，但子类重写了：调用子类的方法

若只有子类有












，则无法调用（需要强制类型转换修改引用类型）

如在Student写一个新的eat方法：

即能调用的方法取决于其引用类型而不是实际类型

方法修饰

static 属于类 
  
  
  
  
  
  
，不属于对象,不可重写

final 无法修改
  
  
  
  
  
  
 ，不可重写

private 只属于父类
 


 


 


 


 


 


 ，无法重写

instanceof操作符

语法：

obj instanceof class System.out.println(s instanceof Student);//true System.out.println(s1 instanceof Student);//true System.out.println(s1 instanceof Object);//true System.out.println(s2 instanceof Student);//true System.out.println(s2 instanceof Teacher);//false

如果对象的类是class或class的子类 
 
 
 
 
 
 
，则为True

在编译状态中
   
   
   
   
   
   
 ，class可以是object对象的父类
 

 

 

 

 

 

 ，自身类 

 

 

 

 

 

 
，子类 
 
 
 
 
 
 。在这三种情况下Java编译时不会报错 
   
   
   
   
   
   
 。(需要在同一条继承链上)

在运行转态中             ，class可以是object对象的父类

 
 

 
 

 
 

 
 

 
 

 
 

 ，自身类












，不能是子类
 

 

 

 

 

 

。在前两种情况下result的结果为true                    ，最后一种为false
 

 

 

 

 

 

 。但是class为子类时编译不会报错             。运行结果为false 

 
 

 
 

 
 

 
 

 
 

 
 

。

编译的时候查看其引用类型判断是否报错












。

运行的时候查看其实际类型判断是否为true                    。

强制类型转换

优先级：父类>子类 
 
 
 
 
 
 
 
 
 
 
 
 
。

子类转父类自动转换



















。

父类转子类需要强制转换             。

转父类后部分方法可能无法再调用 
  
 
  
 
  
 
  
 
  
 
  
 
 。

static

static修饰（静态）的从属于类
 
 
 
 
 
 
 
 
 
 
 
 
 ，普通的从属于对象

静态方法不能调用非静态成员

变量

静态变量（类变量）

有static修饰的变量为静态变量



















，在该类的内存中只能存在一个             ，可以使用类名.变量名进行访问 内部任何方法都可以直接访问静态变量（可以不使用类名.静态成员进行访问） 类外部可以使用类名访问类中静态变量

实例变量

无static修饰的变量

每创建一个实例就会生成一个新的内存空间

类内部只有非静态方法可以访问实例变量

静态方法或其他类中只能通过实例对象访问

静态变量的作用

静态变量被所有实例共享
  
 
  
 
  
 
  
 
  
 
  
 
  ，可以作为实例对象间的共享数据 如果所有实例都有一个相同的常量属性












，可以定义为static以节省空间

方法

静态方法（类方法）

静态方法不需要通过任何实例就可以被调用 
  
  
  
  
  
  
， 不能使用this/super关键字 也不能直接访问类内部的实例变量和实力方法 可以直接调用类内部的静态变量和静态方法

实例方法

通过实例对象访问

代码块

静态代码块

static{}代码块 用于初始化类（一次性的）
  
  
  
  
  
  
 ，为类的静态变量赋初值 类似于一个方法
 


 


 


 


 


 


 ，但不在方法体中 可以在类的任意位置 
 
 
 
 
 
 
，可以有任意多个 java虚拟机在加载类的时候执行静态代码块 多个代码块按顺序运行 静态代码块和静态方法类似
   
   
   
   
   
   
 ，不能访问非静态成员

非静态代码块

{} 创建对象时自动执行
 

 

 

 

 

 

 ，不创建对象不执行 代码域中的变量都是局部的 

 

 

 

 

 

 
，只在内部使用

抽象

abstract修饰

抽象类

abstract修饰的方法 抽象类中可以有抽象方法和具体方法 抽象类无法实例化

抽象方法

抽象方法只声明没有方法体 抽象方法必须在抽象类中 子类重写父类时             ，必须重写父类的所有抽象方法 不能用private修饰

 
 

 
 

 
 

 
 

 
 

 
 

 ，因为private阻止重写

实例

public abstract class Shape { public int width; // 几何图形的长 public int height; // 几何图形的宽 public Shape(int width, int height) { this.width = width; this.height = height; } public abstract double area(); // 定义抽象方法












，计算面积 } public class Square extends Shape { public Square(int width, int height) { super(width, height); } // 重写父类中的抽象方法                    ，实现计算正方形面积的功能 @Override public double area() { return width * height; } } public class Triangle extends Shape { public Triangle(int width, int height) { super(width, height); } // 重写父类中的抽象方法
 
 
 
 
 
 
 
 
 
 
 
 
 ，实现计算三角形面积的功能 @Override public double area() { return 0.5 * width * height; } }

接口

普通类：只有具体实现 抽象类：有具体实现和规范（抽象方法） 接口：只有规范



















，没有具体实现 专业的约束             ，实现约束和实现的分离
  
 
  
 
  
 
  
 
  
 
  
 
  ，比抽象类更加抽象

接口定义

[public] interface interface_name [extends interface1_name[, interface2_name,…]] { // 接口体












，其中可以包含定义常量和声明方法 [public] [static] [final] type constant_name = value; // 定义常量 [public] [abstract] returnType method_name(parameter_list); // 声明方法 } 接口只能继承接口 public定义的接口可以被任何类使用 
  
  
  
  
  
  
，而没有public只能被包内使用 接口中的变量隐式声明为public static final（可以不写）
  
  
  
  
  
  
 ，即为常量
 


 


 


 


 


 


 ，所以全部必须初始化 接口中的方法隐式声明为 public abstract

接口实现

一个类可以实现一个或者多个接口

实现使用implements关键字

<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] { // 主体 }

与继承类似 
 
 
 
 
 
 
，可以获得所有的常量和方法

implements在extend后

类实现接口后必须重写所有抽象方法

例

public interface IMath { public int sum(); // 完成两个数的相加 public int maxNum(int a,int b); // 获取较大的数 } public class MathClass implements IMath { private int num1; // 第 1 个操作数 private int num2; // 第 2 个操作数 public MathClass(int num1,int num2) { // 构造方法 this.num1 = num1; this.num2 = num2; } // 实现接口中的求和方法 public int sum() { return num1 + num2; } // 实现接口中的获取较大数的方法 public int maxNum(int a,int b) { if(a >= b) { return a; } else { return b; } } }

内部类

类内部定义的类

分类：

成员内部类 静态内部类 局部内部类 匿名内部类

内部类还是一个独立的类
   
   
   
   
   
   
 ，会编译为独立的.class文件
 

 

 

 

 

 

 ，但前面会冠以类名和$符号 是内部类的一个成员 

 

 

 

 

 

 
，可以操作到外部类的私有属性 外部类只有两种级别：public和默认 内部类有四种级别：public
  
  
  
  
  
  
 、protected
 


 


 


 


 


 


 、private 
 
 
 
 
 
 
、默认 Outer o = new Outer(); //外部类可直接new Inner in = new Inner(); //外部类外需要通过外部类来实例化内部类 Outer.Inner inner = o.new Inner();

实例内部类

没有static修饰             ，也成为非静态内部类

 
 

 
 

 
 

 
 

 
 

 
 

 ，例:

public class Outer { class Inner { // 实例内部类 } } 和实例方法
   
   
   
   
   
   
 、实例变量相同












，在外部类/外部类以外                    ，必须通过外部类的实例创建内部类的实例 实例内部类中可以访问外部类的所有成员（多层嵌套也可） 外部类中不能直接访问内部类的成员
 
 
 
 
 
 
 
 
 
 
 
 
 ，而必须通过内部类的实例访问（不是很懂） 实例内部类中的成员不能使用static修饰



















，除非同时有final修饰

静态内部类

static修饰的内部类             ，例：

public class Outer { static class Inner { // 静态内部类 } } 可以通过外部类创建内部类的实例 类中可定义静态成员/实例成员 可直接访问外部类的静态成员
  
 
  
 
  
 
  
 
  
 
  
 
  ，如果要访问外部类的实例成员












，则需要通过外部类的实例去访问













。

局部内部类

一个方法中定义的类 
  
  
  
  
  
  
，如:

public class Test { public void method() { class Inner { // 局部内部类 } } } 类似局部变量
  
  
  
  
  
  
 ，不用访问控制修饰符和static修饰符修饰 只在方法内可用 不能定义static成员 内部类的内部类也不能用访问控制修饰符和static修饰符 可访问外部类的所有成员 方法中的成员与外部类成员同名
 


 


 


 


 


 


 ，可以使用 .this. 的形式访问外部类中的成员 
  
  
  
  
  
  。

匿名内部类

没有类名的内部类 
 
 
 
 
 
 
，直接使用new来声明
   
   
   
   
   
   
 ，例：

new <类或接口>() { // 类的主体 };

一般用法：

继承一个类
 

 

 

 

 

 

 ，重写其方法 
  
  
  
  
  
  
 。 实现一个接口（可以是多个） 

 

 

 

 

 

 
，实现其方法

 


 


 


 


 


 


。 public class Out { void show() { System.out.println("调用 Out 类的 show() 方法"); } } public class TestAnonymousInterClass { // 在这个方法中构造一个匿名内部类 private void show() { Out anonyInter = new Out() { // 获取匿名内部类的实例 void show() { System.out.println("调用匿名类中的 show() 方法"); } }; anonyInter.show(); } public static void main(String[] args) { TestAnonymousInterClass test = new TestAnonymousInterClass(); test.show(); } } 和局部内部类相同             ，可访问外部类所有成员 
 
 
 
 
 
 。若位于方法中

 
 

 
 

 
 

 
 

 
 

 
 

 ，只能访问方法中final修饰的量 可以使用非静态代码块进行初始化












，在父类的构造函数后执行