java面向对象怎么学_Java从零开始学习——Java面向对象

面向对象编程

一、面向对象

1、面向对象思想

面向过程思想——步骤清晰简单，按步执行

面向对象思想——分类的思维模式，思考解决问题需要哪些类型，然后分类进行细节思考

适合处理复杂问题，需要多人协作的问题

2、面向对象概念

面向对象编程(Object-Oriented Programming)

本质：以类的方式组织代码，以对象的形式组织(封装)数据

三大特性：封装、继承、多态

二、类与对象

类是一种抽象的数据类型，它是对某一类事物的整体描述、定义，但不代表某一具体的事物

对象即是抽象概念的具体实例

创建对象

1 //默认初始值

2 Class name = new Class();

构造器

String name;//无参构造器，new本质上就是在调用构造器

publicClass()

{//实例化初始值

this.name = "name";

}

​//有参构造器，必须显示无参构造

publicClass(String name)

{this.name = "name";

}

​//Alt + Insert快速创建构造器

三、封装、继承、多态

1、封装

高内聚(类内部的数据操作细节自己完成，不允许外部干涉)、低耦合(仅暴露少量的方法给外部使用)

①提高程序安全性、保护数据

②隐藏代码细节

③统一接口

④提高系统可维护性

属性私有，get、set方法

2、继承

本质是对某一类的抽象

extends，子类是父类的扩展

Java里只有单继承

继承是类与类之间的关系(除此之外，类与类之间的关系还有：依赖、组合、聚合等)

Java中，所有的类都直接或间接的继承Object类

①、this、super

this();本类的构造

super();父类的构造

可调用父类属性或方法，调用父类的构造方法必须在构造方法的第一个，且只能在子类中(super和this不能同时调用构造方法)

private无法继承

子类构造器默认包含父类无参构造器

调用父类构造器必须在子类构造器内的第一行

②、方法重写

//A extends B//A public static void test(){sout(A.test);}//B public static void test(){sout(B.test);}//静态方法的调用只和左边定义的数据类型有关

A a = newA();

a.test();//A.test

​//父类的引用可指向子类

B b = newA();

b.test();//B.test

​//A public void test(){sout(A.test);}//B public void test(){sout(B.test);}//非静态：重写

A a = newA();

a.test();//A.test

​//子类重写的父类的方法

B b = newA();

b.test();//A.test

重写需要有继承关系，子类重写父类的方法

方法名必须相同

参数列表必须相同

修饰符范围可以扩大，但不可缩小 private

抛出异常：范围可以被缩小，但不能扩大——>

1 ClassNotFoundException——>Exception(大)

重写的原因

父类的功能子类不一定需要，或者不一定满足。

3、多态

①、概念

同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向的引用类型不确定

1 Son s1 = newSon();2 Father s2 = new Son();

多态是方法的多态

存在条件：有继承关系、方法重写、父类引用指向子类对象.

1 Father f = new Son();

②、能执行哪些方法

取决于对象左边的类型

子类能调用的方法：自己的以及继承父类的方法

父类能调用的方法：自己的方法

子类重写了父类的方法，就执行子类的方法

static方法，属于类，不属于实例，即不能重写

final修饰的内容为常量，无法重写

private私有的方法也无法重写

③、类型转换&instanceof

instanceof判断两个类之间是否有父子关系

1 //Object > Father > Son2 //Object > Father > Son2

3 Objcet object = newSon();4 System.out.println(object instanceof Son);//true

5 System.out.println(object instanceof Father);//true

6 System.out.println(object instanceof Object);//true

7 System.out.println(object instanceof Son2);//false

8 System.out.println(object instanceof String);//false,对象不在同一条线上，编译不通过，说明是并列关系9

10 //类型转换：父子11 //父方法f();子方法s();12 //高 低

13 Father s = newSon();14 //s不可执行Son里的s();方法，需要强转

15 ((Son)s).s();16 //子类转换为父类，直接转换，可能丢失一些方法

17 Father f = s;

父类和子类有联系才能转换，类型转换抛出异常——>

1 ClassCaseException!

四、Static专题

1、静态/非静态变量

1 private static intage;2 private intscore;3 //静态变量可以直接通过类名访问

4 System.out.println(Class.age);5 //非静态需要创建实例才能引用

6 Class c = newClass();7 System.out.println(c.score);

2、静态/非静态方法

1 //静态方法和main一样和类一同加载

2 public voidv1(){v2();}3 public voidv2(){}4 public static voidv3(){v4();}5 public static voidv4(){}6 ​7 public static voidmain(String[] args)8 {9 //静态方法可以直接访问或者通过类名访问

10 Class.v3();11 v4();12 //非静态需要创建实例才能引用

13 newClass().v1();14 }

3、匿名/静态代码块

1 public classC2 {3 //静态代码块>匿名代码块>构造器,执行循序

4 {5 //匿名代码块，用来赋初始值，只执行一次

6 }7 static

8 {9 //静态代码块，每次实例化都会执行

10 }11 pulic C12 {13 //默认构造器，每次实例化都会执行

14 }15 }

4、静态导入包

1 //import java.lang.Math;

2 import staticjava.lang.Math.random;3 ​4 public static voidmain(String[] args)5 {6 //System.out.println(Math.random());

7 System.out.println(random());8 }

五、抽象类

用abstract修饰的类就是抽象类

继承抽象类的子类必须重写(实现)它的所有方法

抽象方法只能存在抽象类中，但抽象类中可以出现正常方法

存在意义：抽象化，提高开发效率，提高可扩展性

六、接口

1、区别

普通类：只有具体实现

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

接口：只有规范(自己无法写方法)，专业的抽象(约束)，约束和现实分离：面向接口编程

接口不能被实例化，接口中没有构造方法

类只能是单继承，但接口可多继承

1 //接口中定义的方法都是抽象的，public abstract2 //属性定义的都是常量，public static final

3 public interfaceUserService{}4 public interfaceTimeService{}5 //接口都需要有实现类，且必须重写(实现)它的所有方法

6 public class UserImp implements UserService,TimeService{}

2、作用

接口就是规范，定义的是一组规则

接口的本质是契约，如法律，必须遵守

OOP的精髓，是对对象的抽象，最能体现这一点的就是接口

七、内部类

1、成员内部类

在类内部再创建一个类

通过外部类.new来实例化内部类

内部类可以获得外部类的私有属性

一个java类中只能有一个public属性的class，但可以有多个class

这时创建的class、interface可以在main方法中实现匿名调用

2、局部内部类

在类方法内部再创建一个类

八、Exception、Error

Java把异常当做对象来处理，并定义了个基类java.lang.Throwable作为所有异常的超类

异常分为Exception和Error

1、Error

Error是虚拟机生成并抛出的，大多与代码编写者所执行的操作无关

一般是虚拟机JVM运行错误，内存溢出(OutOfMemoryError)时，JVM一般会选择线程终止

虚拟机执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)，这些错误是不可查的

2、Exception

RuntimeException(运行时异常)

ArrayIndexOutOfBoundsException

NullPointerException

ArithmeticException

MissingResourceException

ClassNotFoundException

3、异常处理机制

抛出异常

捕获异常

可以提前捕获异常，使程序的其他内容继续执行

1 //Ctrl + Alt + t 直接建立

2 try

3 {4 //监控区域5 //执行语句6 //满足条件主动抛出异常(算术异常)，一般在方法中使用

7 if(Exception)8 {9 throw newArithmaticException();10 }11 }12 catch(Error er)13 {14 //捕获Error异常，并反馈15 //捕获到Error异常后，后面的捕获直接结束

16 er.printStackTrace();17 }18 catch(Exception ex)19 {20 //捕获Exception异常，并反馈

21 ex.printStackTrace();22 }23 catch(Throwable ta)24 {25 //捕获异常，并反馈

26 ta.printStackTrace();27 }28 finally

29 {30 //处理善后工作，一定执行，用于关闭I/O资源，可不要

31 }32 ​33 //在方法上主动抛异常

34 public void math() throwsArithmaticException35 {36 //满足条件主动抛出异常(算术异常)，一般在方法中使用

37 if(Exception)38 {39 throw newArithmaticException();40 }41 }

自定义异常

1 public class MyException extendsException2 {3 private intdetail;4

5 //创建构造器

6 public MyException(inta)7 {8 this.detail =a;9 }10

11 //创建toString方法，打印异常信息

12 @Override13 publicString toString()14 {15 return "MyException{" +

16 "detail" +detail17 + '}';18 }19 }20 ​21 //引用，要么在方法上抛出throws，要么在方法内捕获try/catch