面向过程&面向对象
面向过程的思维模式
面向过程的思维模式是简单的线性思维，思考问题首先陷入第一步做什么、第二步做什么的细节中。这种思维模式适合处理简单的事情
面向对象的思维模式
面向对象的思维模式说白了就是分类思维模式。思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。这样就可以形成很好的协作分工。比如：设计师分了10个类，然后将10个类交给了10个人分别进行详细设计和编码。显然，面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理
OOP详解
1、什么是面向对象
Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程
(Object-OrientedProgramming, OOP)。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
抽象(abstract)
忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了
解全部问题，而只是选择其中的一部分，暂时不用关注细节。
例如:要设计一个学生成绩管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他
的身高、体重这些信息。 抽象是什么?就是将多个物体共同点归纳出来，就是抽出像的部分！
封装(Encapsulation)
- 封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过指定的方式。
- 在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
- 信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。
- 封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。
继承(inheritance)
1. 继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
2. 新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为
新类的基类(父类)。
3. 派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增
加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应
用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有
的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。
多态(polymorphism)
1.多态性是指允许不同类的对象对同一消息作出响应。
2.多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
相同类域的不同对象,调用相同方法,表现出不同的结果
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。
2、类与对象的关系
类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.
例如：我们生活中所说的词语：动物、植物、手机、电脑等等。这些也都是抽象的概念,而不是指的某一
个具体的东西。
例如: Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
例如：张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。能够体现出特点,展现出功
能的是具体的实例,而不是一个抽象的概念.
【示例】
Student s = new Student(1L,"tom",20);
s.study();
Car c = new Car(1,"BWM",500000);
c.run();
对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类只是给对象的创建提供了一个参考的模板而已.
但是在java中,没有类就没有对象,然而类又是根据具体的功能需求,进行实际的分析,最终抽象出来的.
3、对象和引用的关系
引用 "指向" 对象
使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引用。
在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是所说的引用指向对象.
方法回顾及加深
方法一定是定义在类中的,属于类的成员。
1、方法的定义
格式： 修饰符 返回类型 方法名(参数列表)异常抛出类型{...}
- 修饰符
public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口
main方法，就使用了public static这个俩个修饰符
注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的
- 返回类型
方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必
须写void.
只有构造方法(构造器)不写任何返回类型也不写void
【示例】
public String sayHello(){
return "hello";
}
public int max(int a,int b){
return a>b?a:b;
}
public void print(String msg){
System.out.println(msg);
}
- 方法名
遵守java中标示符的命名规则即可
- 参数列表
根据需求定义,方法可以是无参的,也可以有一个参数,也可以有多个参数
- 异常抛出类型
如果方法中的代码在执行过程中,可能会出现一些异常情况,那么就可以在方法上把这些异常声明并抛出,
也可以同时声明抛出多个异常,使用逗号隔开即可
【示例】
public void readFile(String file)throws IOException{
}
public void readFile(String file)throws IOException,ClassNotFoundException{
}
2、方法调用
在类中定义了方法,这个方法中的代码并不会执行,当这个方法被调用的时候,方法中的代码才会被一行一行顺序执行。
- 非静态方法
没有使用static修饰符修饰的方法,就是非静态方法.
调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)
【例子】
public class Student{
public void say(){}
}
public static void main(String[] args) {
Student s = new Student();
s.say();
}
- 静态方法
使用static修饰符修饰的方法,就是静态方法.
调用这种方法的时候,"可以"使用对象调用,也"可以"使用类来调用,但是推荐使用类进行调用,因为静态
方法是属于类的。(静态属性也是一样的)
【例子】
public class Student{
public static void say(){}
}
public static void main(String[] args) {
Student.say();
}
- 类中方法之间的调用
假设同一个类中有俩个方法,a方法和b方法，a和b都是非静态方法，相互之间可以直接调用
public void a(){
b();
}
public void b(){
}
a和b都是静态方法,相互之间可以直接调用
public static void a(){
b();
}
public static void b(){
}
a静态方法,b是非静态方法，a方法中不能直接调用b方法,但是b方法中可以直接调用a方法. 静态方法不能调用非静态方法
另外：在同一个类中,静态方法内不能直接访问到类中的非静态属性
总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方法是非静态的时候，非静态方法可以调用静态方法，反之不能
3、调用方法时的传参
- 形参和实参
【例子】
// a = x;
public void test(int a){
//..
}
public static void main(String[] args) {
int x = 1;
t.test(x);
}
参数列表中的a是方法test的形参(形式上的参数)
调用方法时的x是方法test的实参(实际上的参数)
注意：形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关
心变量的类型以及变量接收的值
- 值传递和引用传递
调用方法进行传参时,分为值传递和引用传递两种。
如果参数的类型是基本数据类型,那么就是值传递。
如果参数的类型是引用数据类型,那么就是引用传递。
值传递是实参把自己变量本身存的简单数值赋值给形参.
引用传递是实参把自己变量本身存的对象内存地址值赋值给形参.
所以值传递和引用传递本质上是一回事,只不过传递的东西的意义不同而已.
【示例：值传递】
public class Test{
public static void changeNum(int a){
a = 10;
}
public static void main(String[] args){
int a = 1;
System.out.println("before: a = "+a); //1
changeNum(a);
System.out.println("after: a = "+a); //1
}
}
【示例：引用传递】
public class Demo03 {
public static void changeName(Student s){
s.name = "tom";
}
public static void main(String[] args){
Student s = new Student();
System.out.println("before: name = "+s.name); //null
changeName(s);
System.out.println("after: name = "+s.name); //tom
}
}
class Student{
String name;
}
4、this关键字
在类中,可以使用this关键字表示一些特殊的作用
1、this在类中的作用
【区别成员变量和局部变量】
public class Student{
private String name;
public void setName(String name){
//this.name表示类中的属性name
this.name = name;
}
}
【调用类中的其他方法】
public class Student{
private String name;
public void setName(String name){
this.name = name;
}
public void print(){
//表示调用当前类中的setName方法
this.setName("tom");
}
}
注：默认情况下,setName("tom")和this.setName("tom")的效果是一样的
【调用类中的其他构造器】
public class Student{
private String name;
public Student(){
//调用一个参数的构造器,并且参数的类型是String
this("tom");
}
public Student(String name){
this.name = name;
}
}
注:this的这种用法,只能在构造器中使用.普通的方法是不能用的.并且这句调用的代码只能出现在构造器中的第一句.
【示例】
public class Student{
private String name;
//编译报错,因为this("tom")不是构造器中的第一句代码.
public Student(){
System.out.println("hello");
this("tom");
}
public Student(String name){
this.name = name;
}
}
2、this关键字在类中的意义
this在类中表示当前类将来创建出的对象
【例子】
public class Student{
private String name;
public Student(){
System.out.println("this = "+this);
}
public static void main(String[] args){
Student s = new Student();
System.out.println("s = "+s);
}
}
运行后看结果可知,this和s打印的结果是一样的,那么其实也就是变量s是从对象的外部执行对象,而this是在对象的内部执行对象本身.
这样也就能理解为什么this.name代表的是成员变量,this.setName("tom")代表的是调用成员方法,因为这俩句代码从本质上讲,和在对象外部使用变量s来调用是一样的,s.name和s.setName("tom")。
【this和s打印出来的内存地址是一样的,使用==比较的结果为true。】
public class Student{
public Student getStudent(){
return this;
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = s1.getStudent();
System.out.println(s1 == s2);//true
}
}
【 类中的this是和s1相等还是和s2相等呢?】
public class Student{
private String name;
public void test(){
System.out.println(this);
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
s1.test();
s2.test();
}
}
注:这句话是要这么来描述的,s1对象中的this和s1相等,s2对象中的this和s2相等,因为类是模板,模板中写的this并不是只有一个,每个对象中都有一个属于自己的this,就是每个对象中都一个属于自己的name属性一样.
创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化 以 及对类中构造器的调用
那么对main方法中的以下代码:
Student s = new Student();
1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋
值)
2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)
例如:显式赋值
private String name = "tom";
3)调用构造器
4)把对象内存地址值赋值给变量。(=号赋值操作)
构造器
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void
构造器的作用:
- 使用new创建对象的时候必须使用类的构造器
- 构造器中的代码执行后,可以给对象中的属性初始化赋值
【演示】
public class Student{
private String name;
public Student(){
name = "tom";
}
}
构造器重载
除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值.
public class Student{
private String name;
public Student(){
name = "tom";
}
public Student(String name){
this.name = name;
}
}
构造器之间的调用
使用this关键字,在一个构造器中可以调用另一个构造器的代码
注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键
字才会创建新对象
【演示】
public class Student{
private 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();
内存分析
JAVA程序运行的内存分析
栈 stack：
- 每个线程私有，不能实现线程间的共享！
- 局部变量放置于栈中
- 栈是由系统自动分配，速度快！栈是一个连续的内存空间
堆 heap：
- 放置new出来的对象
- 堆是一个不连续的内存空间，分配灵活，速度慢
方法区(也是堆)
- 被所有线程共享
- 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）
引用类型的概念 - java中，除了基本数据类型之外的其他类型称之为引用类型
- java中的对象是通过引用来操作的
属性（field，或者叫成员变量） - 属性用于定义该类或该类对象包含的数据或者说静态属性
- 属性作用范围是整个类体
- 属性的默认初始化：
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值：0,0.0char:u0000, boolean:false, 所有引用类型:null) - 属性定义格式：
[修饰符] 属性类型 属性名 = [默认值]
类的方法
方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序有一个个函数调用组成；面向对象中，整个程序的基本单位是类，方法是从属于类或对象的
方法定义格式：
[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}
java对象的创建和使用
- 必须使用 new 关键字创建对象。
Person person= new Person ();
- 使用对象（引用） . 成员变量来引用对象的成员变量
person.age
- 使用对象（引用） . 方法（参数列表）来调用对象的方法
person.setAge(23)
类中就是：//静态的数据 //动态的行为
封装
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
1、封装的步骤
- 使用private 修饰需要封装的成员变量。
- 提供一个公开的方法设置或者访问私有的属性
设置 通过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());
}
}
2、作用和意义
- 提高程序的安全性，保护数据。
- 隐藏代码的实现细节
- 统一用户的调用接口
- 提高系统的可维护性
- 便于调用者调用
良好的封装，便于修改内部代码，提高可维护性
3、方法重载
类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载可以提供方法调用的灵活性。
【演示：查看println方法的重载】
public class Test{
public void test(String str){
}
public void test(int a){
}
}
方法重载必须满足以下条件
- 方法名必须相同
- 参数列表必须不同(参数的类型、个数、顺序的不同)
public void test(Strig str){}
public void test(int a){}
public void test(Strig str,double d){}
public void test(Strig str){}
public void test(Strig str,double d){}
public void test(double d,Strig str){}
- 方法的返回值可以不同，也可以相同。
在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表
继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
为什么需要继承？继承的作用？
第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象
第二好处：为了提高代码的复用性
【注】JAVA中类只有单继承，没有多继承！ 接口可以多继承！
1、继承
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等
- 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
public class student extends Person{
}
- 子类和父类之间,从意义上讲应该具有"is a"的关系.
student is a person
dog is a animal
- 类和类之间的继承是单继承
一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多子类继承,就像一个父亲可以有多个孩子
注:java中接口和接口之间,有可以继承,并且是多继承。
- 父类中的属性和方法可以被子类继承
子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。
例如 :
父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super关键字)
2、Object类
java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is a 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方法等
3、Super关键字
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法
- super的使用
【访问父类中的属性】
public class Person{
protected String name = "zs";
}
public class Student extends Person{
private String name = "lisi";
public void tes(String name)t{
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不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置
【例子】
public class Person{
protected String name;
public Person(String name){
this.name = name;
}
}
public class Student extends Person{
//编译报错,super调用构造器的语句不是第一行代码
public Student(){
System.out.println("Student");
super("tom");
}
}
【例子】
public class Person{
protected String name;
public Person(String name){
this.name = name;
}
}
//编译通过
public class Student extends Person{
private int age;
public Student(){
this(20);
}
public Student(int age){
super("tom");
this.age = age;
}
}
【super使用的注意的地方】
- 用super调用父类构造方法，必须是构造方法中的第一个语句。
- super只能出现在子类的方法或者构造方法中。
- super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）
【super 和 this 的区别】 - 代表的事物不一样:
this：代表所属方法的调用者对象
super： 代表父类对象的引用空间。 - 使用前提不一致：
this：在非继承的条件下也可以使用。
super：只能在继承的条件下才能使用 - 调用构造方法
this：调用本类的构造方法
super：调用的父类的构造方法
4、方法重写
方法的重写（override）
- 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写
- 静态方法不能重写
- 父类的静态方法不能被子类重写为非静态方法 //编译出错
- 父类的非静态方法不能被子类重写为静态方法；//编译出错
- 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
【例子】
A类继承B类 A和B中都一个相同的静态方法test
B a = new A();
a.test();//调用到的是B类中的静态方法test
A a = new A();
a.test();//调用到的是A类中的静态方法test
可以看出静态方法的调用只和变量声明的类型相关
这个和非静态方法的重写之后的效果完全不同
私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。
【例子】
public class Person{
private void run(){}
}
//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法
public class Student extends Person{
private void run(){}
}
重写的语法
- 方法名必须相同
- 参数列表必须相同
- 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
- 抛出异常类型的范围可以被缩小,但是不能被扩大
ClassNotFoundException ---> Exception - 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型
例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型
注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号中代码不一样)
public class Person{
public void run(){}
protected Object test()throws Exception{
return null;
}
}
//编译通过,子类继承父类,重写了run和test方法.
public class Student extends Person{
public void run(){}
public String test(){
return "";
}
}
为什么要重写？
子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需要把方法进行重写。
总结：
- 方法重写的时候，必须存在继承关系
- 方法重写的时候，方法名和形式参数 必须跟父类是一致的
- 方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <public，friendly < public )
- 方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系
- 方法重写的时候，子类的异常类型要小于或者等于父类的异常类型
多态
1、认识多态
多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。
多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加
灵活的编程，提高系统的可扩展性。
允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式
相同类域的不同对象,调用相同的方法,执行结果是不同的
- 一个对象的实际类型是确定的
例如: new Student(); new Person();等
- 可以指向对象的引用的类型有很多
一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。
例如: Student继承了Person类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
因为Person和Object都是Student的父类型
注:一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。
- 一个父类引用可以指向它的任何一个子类对象
例如：
Object o = new AnyClass();
Person p = null;
p = new Student();
p = new Teacher();
p = new Person();
- 多态中的方法调用
public class Person{
public void run(){}
}
public class Student extends Person{
}
- 调用到的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();
变量s能调用的方法是Student中有的方法(包括继承过来的),变量p能调用的方法是Person中有的方法(包括继承过来的)
但是变量p是父类型的,p不仅可以指向Student对象,还可以指向Teacher类型对象等,但是变量s只能指Studnet类型对象,及Student子类型对象。变量p能指向对象的范围是比变量s大的。Object类型的变量o,能指向所有对象,它的范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法,因为变量o声明的类型就是Object.
注：java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。
2、重写、重载和多态的关系
重载是编译时多态
调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错
重写是运行时多态
调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行
期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用,
是运行时动态和对象绑定的)
3、多态的注意事项
- 多态是方法的多态，属性没有多态性
- 编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常
- 多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象
4、多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）： - static方法，因为被static修饰的方法是属于类的，而不是属于实例的
- final方法，因为被final修饰的方法无法被子类重写
- private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢
5、方法绑定(method binding)
执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。
静态绑定：
在编译期完成，可以提高代码执行速度。
动态绑定：
通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了final类、final方、static方法，所有方法都是JVM在运行期才进行动态绑定的。
多态：如果编译时类型和运行时类型不一致，就会造成多态。
6、instanceof和类型转换
1. 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
2. 类型转换
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的抽象编程思想。
修饰符
1、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("构造器");
}
}
【匿名代码块和静态代码块的作用】
匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。
静态代码块的作用是给类中的静态成员变量初始化赋值。
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类之前没有进行类加载】
- 类加载,同时初始化类中静态的属性
- 执行静态代码块
- 分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
- 调用Student的父类构造器
- 对Student中的属性进行显示赋值(如果有的话)
- 执行匿名代码块
- 执行构造器
- 返回内存地址
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 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);
}
}
2、final修饰符
1、修饰类
用final修饰的类不能被继承,没有子类
例如:我们是无法写一个类去继承String类,然后对String类型扩展的,因为API中已经被String类定义为final的了
我们也可以定义final修饰的类:
public final class Action{
}
//编译报错
public class Go extends Action{
}
2、修饰方法
用final修饰的方法可以被继承,但是不能被子类的重写
例如:每个类都是Object类的子类,继承了Object中的众多方法,在子类中可以重写toString方法、equals方法等,但是不能重写getClass方法 wait方法等,因为这些方法都是使用fianl修饰的
我们也可以定义final修饰的方法:
public class Person{
public final void print(){}
}
//编译报错
public class Student extends Person{
public void print(){
}
}
3、修饰变量
用final修饰的变量表示常量,只能被赋一次值.其实使用final修饰的变量也就成了常量了,因为值不会再变了。
【修饰局部变量】
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();
3、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();
接口
1、接口的本质
普通类：只有具体实现
抽象类：具体实现和规范(抽象方法) 都有
接口：只有规范
【为什么需要接口?接口和抽象类的区别?】
- 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
- 抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范
- 从接口的实现者角度看，接口定义了可以向外部提供的服务
- 从接口的调用者角度看，接口定义了实现者能提供那些服务
- 接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。
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 final修饰)
接口中可以不写任何属性,但如果写属性了,该属性必须是public static final修饰的静态常量。
注:可以直接使用接口名访问其属性。因为是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,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
9、 一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
