你的位置:首页 > Java教程

[Java教程]OPP


第一天

1.什么是类?什么是对象?

  1)现实世界是由很多很多对象组成的

    基于对象抽出了类

  2)对象:真真正正存在的单个的个体

    类:代表一类个体(类型、类别)

  3)类中可以包含:

    3.1)所有对象所共有的属性(静)----变量

    3.2)所有对象所共有的行为(动)----方法

  4)一个类可以创建多个对象

    同一个类创建的多个对象,结构相同,数据不同

  5)类是对象的模板,对象是类的具体的实例

2.如何创建类?如何创建对象?

3.引用类型画等号:

  1)指向同一个对象

  2)对其中一个引用的修改会影响另外一个

    eg:房门钥匙

  基本类型画等号:

  1)赋值

  2)对其中一个值的修改不会影响另外一个

    eg:身份证复印件

4.null:空,即不指向任何对象

       若引用的值为null,则该引用不能再进行任何操作了

       若操作则空指针异常(NullPointerException)

补充

1. 1)找对象:一堆小格子

2)抽类:格子类Cell

3)设计类中的成员变量和方法:

4)创建对象:

2. 面向过程是一种以过程为核心的编程思想,即分析出解决问题所需要的步骤,然后使用方法将这些步骤一步一步的实现,使用的时候,在main方法中一个一个依次调用就可以了。

3. 请描述类和对象的关系

参考答案

对象是一个客观存在的实体,是面向对象编程过程中分析与解决问题的出发点与基础。对象的实质就是内存中的一块数据存储区域,其数据结构由定义它的类来决定。

类是用于构建对象的模板,对象通过类的实例化产生,一个类可以创建多个对象,每个对象拥有自己的数据和行为。

3 请描述引用类型和基本类型的区别

参考答案

除8种基本类型之外,用类名(接口、数组)声明的变量称为引用类型变量,简称“引用”。引用的功能在于访问对象。

基本类型变量本身就包含了其实例数据,而引用类型变量中存储的是某个对象在内存中的地址信息。当一个引用类型变量指向该类的对象时,就可以通过这个变量访问对象。

第二天

1.方法的签名:方法名+参数列表

2.方法的重载:

  1)同一个类中,方法名称相同,参数列表不同

  2)编译器在编译时自动根据方法的签名绑定调用不同的方法

3.构造方法:构造函数、构造器、构建器

  1)给成员变量赋初值

  2)与类同名,没有返回值类型

  3)在创建(new)对象时被自动调用

  4)若自己不写构造,则系统默认提供一个无参构造方法

    若自己写了构造,则不再默认提供

  5)构造方法可以重载

4.this:指代当前对象,哪个对象调指的就是哪个对象

       方法中访问成员变量之前,默认有个this.

  this用法:

  1)this.成员变量名----访问成员变量

  2)this.方法名()------调用方法

  3)this()-------------调用构造方法

5.引用类型数组

  1)

1   Cell[] cells = new Cell[4];2   cells[0] = new Cell(2,5);3   cells[1] = new Cell(3,6);4   cells[2] = new Cell(4,7);5   cells[3] = new Cell(5,8);

2)

1   Cell[] cells = new Cell[]{2    new Cell(2,5),3    new Cell(3,6),4    new Cell(4,7),5    new Cell(5,8)6   }

  3)

1   int[][] arr = new int[3][];2   arr[0] = new int[2];3   arr[1] = new int[3];4   arr[2] = new int[2];5   arr[1][0] = 100; //arr中第2个元素中的第1个元素赋值为100

4)

1 int[][] arr = new int[3][4]; //3行4列2   for(int i=0;i<arr.length;i++){3    for(int j=0;j<arr[i].length;j++){4     arr[i][j] = 100;5    }6   }

1)找对象:T对象,J,O,I,S,Z,L

2)抽类:T类,J类,L类,O,S,Z,I类

3)设计类中的成员变量和方法:

4)创建对象测试:

知识点补充:

1.一个文件中可以包含多个类

 public修饰的类只能有一个

 public修饰的类的名字必须与文件名相同

第三天

1.内存管理:理解

  1)堆:

    1.1)存储所有new出来的对象

    1.2)成员变量的生命周期:

          创建对象时存在堆中,对象被回收时一并消失

    1.3)没有任何引用所指向的对象即为垃圾,

        垃圾回收器(GC)不定时查看,看到垃圾则自动回收

    1.4)内存泄露:无用的对象没有被及时的回收

          建议:若对象不再使用,及时将引用设置为null

  2)栈:

    2.1)存储正在调用的方法中的所有局部变量

    2.2)调用方法时在栈中为该方法分配一块对应的栈帧,

        栈帧中存储方法中的局部变量,

               方法执行结束时栈帧被消除,局部变量一并消失

    2.3)局部变量的生命周期:

          方法被调用时存在栈中,方法结束时栈帧被消除时一并消失

  3)方法区:

    3.1)存储.class字节码文件以及所有方法

    3.2)方法只有一份,通过this来区分具体的引用

2.继承:

  1)有利于代码的重用(避免代码重复)

  2)通过extends实现继承

  3)父类/基类:所有子类所共有的特征和行为

    子类/派生类/:子类所特有的特征和行为

  4)子类继承父类后,具有:

      父类共有的+子类特有的

  5)一个父类可以有多个子类,

    一个子类只能有一个父类---单一继承

  6)继承具有传递性

  7)java规定:构造子类之前必须先构造父类

    子类构造中若没有调用父类构造,则默认添加super()来调用父类的无参构造

    若子类构造中调了父类构造,则不再默认提供

    super()必须位于子类构造的第一句

3.super:指代当前对象的父类对象

  用法:

  1)super.成员变量名---访问父类的成员变量

  2)super.方法名()-----调用父类的方法

  3)super()------------调用父类的构造方法

4.向上造型

  1)父类型的引用指向子类的对象

  2)能点出来什么,看引用的类型

知识点补充:

1.成员变量:

1)类中,方法外

2)new时存在堆中,对象被回收时一并被清除

3)有默认值

局部变量:

1)方法中

2)方法被调用时存在栈中,调用结束栈帧被清除时一并消失

3)没有默认值

成员变量:有几个对象就有几份(堆)

成员方法:只有一份(方法区)

2. 在JAVA中,有java程序、虚拟机、操作系统三个层次,其中java程序与虚拟机交互,而虚拟机与操作系统交互。编译好的java字节码文件运行在JVM中。

程序中无论代码还是数据,都需要存储在内存中,而java程序所需内存均由JVM进行管理分配,开发者只需关心JVM是如何管理内存的,而无需关注某种操作系统是如何管理内存的,这就保证了java程序的平台无关性。

JVM会将申请的内存从逻辑上划分为三个区域:堆、栈、方法区。这三个区域分别用于存储不同的数据。

3.GC线程会从栈中的引用变量开始跟踪,从而判定哪些内存是正在使用的,若GC无法跟踪到某一块堆内存,那么GC就认为这块内存不再使用了,即为可回收的。但是,java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。

4. 构建T类和J类的父类Tetromino类,将公共的(T类和J类公有的)信息存放在父类中, T类和J类继承Tetromino父类。此时,子类即可以共享父类的数据。这个过程就是泛化的过程。

5.简述JVM垃圾回收机制

垃圾回收机制是Java提供的自动释放内存空间的机制。

垃圾回收器(Garbage Collection,GC)是JVM自带的一个线程,用于回收没有被引用的对象。

6 Java程序是否会出现内存泄露

会出现内存泄漏。一般来说内存泄漏有两种情况。

一是在堆中分配的内存,在没有将其释放掉的时候,就将所有能访问这块内存的方式都删掉;另一种情况则是在内存对象明明已经不需要的时候,还仍然保留着这块内存和它的访问方式(引用)。第一种情况,在Java中已经由于垃圾回收机制的引入,得到了很好的解决。所以,Java中的内存泄漏,主要指的是第二种情况。

7.Foo foo = new Foo();

foo.f();

以上代码的内存实现原理为:

1.Foo类首先被装载到JVM的方法区,其中包括类的信息,包括方法和构造等。

2.在栈内存中分配引用变量foo。

3.在堆内存中按照Foo类型信息分配实例变量内存空间;然后,将栈中引用foo指向foo对象堆内存的首地址。

4.使用引用foo调用方法,根据foo引用的类型Foo调用f方法。

8.当调用子类构造器来初始化子类对象时,父类构造器总会在子类构造器之前执行。子类构造器调用父类构造器分如下几种情况。

A,子类构造器执行体的第一行使用super显式调用父类构造器,系统将根据super调用里传入的实参列表调用父类对应的构造器。

B,子类构造器执行的第一行代码使用this显式调用本类中重载的构造器,系统将根据this调用里传入的实参列表调用本类中的另一个构造器。执行本类中另一个构造器时即会调用父类构造器。

C,子类构造器执行体中既没有super调用,也没有this调用,系统将会在执行子类构造器之前,隐式调用父类无参数的构造器。

第四天

1.方法的重写(override):

  1)发生在父子类中,方法名相同,参数列表相同,方法体不同

  2)重写方法被调用时,看对象

2.重写与重载的区别:----常见面试题

  1)重写:

    1.1)父子类中,方法名相同,参数列表相同

    1.2)遵循"运行期"绑定,根据对象的类型调用方法

  2)重载(overload):

    2.1)同一个类中,方法名相同,参数列表不同

    2.2)遵循"编译期"绑定,根据引用的类型绑定方法

3.package:

  1)避免类的命名冲突

  2)类的完全限定名:包名.类名

  3)包名建议所有字母小写

  import:

  1)同包中的类可以直接访问,

    不同包中类访问两种方式:

    1.1)通过import声明类/引入类

    1.2)完全限定名----繁琐

  2)语法: import 包名.类名;

4.访问控制修饰符:

  1)public:公开的,任何类

  2)private:私有的,本类

  3)protected:受保护的,本类、子类、同包类

  4)默认:什么也不写,本类、同包类

  说明:

    1)类的访问控制只能是public和默认

    2)类中的成员如上4种都可以

5.static:静态的

  1)静态变量:

    1.1)由static修饰

    1.2)是属于类的,存在方法区中,只有一份

    1.3)常常通过类名.来访问

    1.4)何时用:所有对象的数据都一样时使用

  2)静态方法:

    2.1)由static修饰

    2.2)是属于类的,存在方法区中,只有一份

    2.3)常常通过类名.来访问

    2.4)静态方法没有隐式this传递,

        所以静态方法中不能直接访问实例成员

    2.5)何时用:方法的操作仅与参数相关而与对象无关

  3)静态块:

    3.1)由static修饰

    3.2)类被加载时自动执行,类只被加载一次,

        静态块只执行一次

    3.3)何时用:常常用于加载静态资源(图片、音频、视频等)

6.final:最终的

  1)修饰变量:变量不能被改变

  2)修饰方法:方法不能被重写

  3)修饰类:类不能被继承

7.static final-----------自学

补充知识点:

1.实例变量多还是静态变量多?

----------实例变量多

----------静态方法不可能多

2. 静态方法没有隐式的this传递,

没有this意味着没有对象,

实例变量是属于对象,必须通过对象点来访问

所以静态方法中不能直接访问实例成员

3. 成员变量:

1)实例变量:属于对象的,存在堆中,

           有几个对象有几份  通过对象点来访问

2)静态变量:属于类的,存在方法区中,

           只有一份   通过类名点来访问

4.重写遵守"两同两小一大"原则:----等于时绝对正确

 * 1)两同:

 *   1.1)方法名相同

 *   1.2)参数列表相同

 * 2)两小:

 *   2.1)子类的返回值类型小于或等于父类的

 *       2.1.1)void和基本类型时,必须相同

 *       2.1.2)引用类型时,小于或等于父类的

 *   2.2)子类抛出的异常小于或等于父类的-----异常之后

 * 3)一大:

 *   3.1)子类的访问权限大于或等于父类的-----修饰符之后

5.方法重载的要求是“两同一个不同“的原则,

* 1)两同:

*   1.1)方法名相同,

同一类中是指两个方法可以是同一个类中声明的,或者是继承来的,抑或一个是声明的,另一个是继承来的

 *   1.2) 同一类

* 2)一不同:参数列表不同

6. 对于类的修饰可以使用public和默认方式。 其中,public修饰的类可以被任何一个类使用,而默认访问控制的类只可以被同一个包中的类使用。

而protected和private访问修饰符是不可以修饰类的,但其可以修饰内部类(后面课程详细介绍)。

7. 关于package和import语句,下面说法错误的是:

A. package 提供了一种命名机制,用于管理类名空间

B. 定义类时,除了定义类的名称以外,必须要指定一个包名

C. import语句用于导入所需要的类

D. 同时使用不同包中相同类名的类,包名不能省略

8. final关键字修饰成员变量,意为初始化后不可改变(对象一旦创建即不可改变),那么该成员变量可以在声明时赋初始值,也可以在构造方法或是静态代码块中初始化。

第五天

1.static final常量:

  1)常量必须声明同时初始化

  2)不能被改变、通过类名.来访问

  3)常量名建议所有字母大写,多个单词用_分隔

  4)在编译时被直接替换为具体的值---效率高

2.抽象方法:

  1)由abstract修饰

  2)只有方法的定义,没有方法的具体实现(连{}都没有)

3.抽象类:

  1)由abstract修饰

  2)包含抽象方法的类必须是抽象类

    若一个类中没有抽象方法,也可以声明为抽象类---我愿意

  3)抽象类不能被实例化(new)

  4)抽象类是需要被继承的,子类:

    4.1)重写父类的所有抽象方法--常用

    4.2)也声明为抽象类----不常用

  5)抽象类的意义:

    5.1)封装子类所共有的数据和行为--子类重用

    5.2)为所有子类提供了一种公共的类型--向上造型

    5.3)包含抽象方法,为所有子类提供统一的入口

4.接口:

  1)是一个标准、规范

    只要符合了这个标准、就能干某件事---API

  2)由interface定义

  3)只能包含常量和抽象方法

  4)接口不能被实例化

  5)接口是需要被实现/继承的,实现类/子类:

      必须重写接口中的所有抽象方法

  6)一个类可以实现多个接口,

    若又继承又实现时,必须先继承后实现

  7)接口可以继承接口

补充知识点

1. 抽象类中可以包含抽象方法和非抽象方法,而接口中的所有方法均为抽象的。

2. 接口里不包含构造器;抽象类里可以包含构造器,抽象类里的构造器并不是用于创建对象,而是让其子类调用这些构造器来完成属于抽象类的初始化操作

3. //演示接口的基础语法

1 interface Inter1{ 2   public static final int NUM = 250;3   public abstract void show();4   double PI = 3.14159;      //默认public static final5   void say();              //默认public abstract6 }

 

第六天

正课:

1.多态:多种形态

  1)多态的意义:

    1.1)同一类型的引用在指向不同的对象时,有不同的实现

          行为的多态: cut(),run()

    1.2)同一对象被造型为不同的类型时,有不同的功能

          对象的多态: 我,水

  2)向上造型:

    2.1)父类型的引用指向子类的对象

    2.2)能造型成的类型:父类、所实现的接口

    2.3)能点出来什么,看引用的类型

  3)强制类型转换,成功的条件只有两个:

    3.1)引用所指向的对象,就是该类型

    3.2)引用所指向的对象,实现了该接口

  4)只要不符合如上两个条件,

    则发生ClassCastException类型转换异常

    一般在转换之前先通过instanceof判断:

      引用所指向的对象是否是该类型

2.成员内部类:单独应用的几率不太大

  1)类中套类,里面的叫内部类Inner,外面的叫外部类Outer

  2)内部类通常只服务于外部类,对外不具备可见性

  3)通常在外部类中创建内部类的对象

  4)内部类中可以直接访问外部类的成员(包括私有的)

    内部类中有一个隐式的引用指向了创建它的外部类对象

      外部类名.this.

3.匿名内部类:

  1)想创建一个类(子类)的对象,并且该对象只创建一次,

    此时该类不必命名,称之为匿名内部类

  2)内部类(成员、匿名)有独立的.class

4.面向对象三大特征:

  1)封装:

    1.1)类:封装的是对象的特征和行为

    1.2)方法:封装的具体的业务逻辑/实现

    1.3)访问控制修饰符:封装的是访问的权限

  2)继承:

    2.1)便于代码的重用

    2.2)extends,父:共有的 子:特有的

  3)多态:

    3.1)意义:

        3.1.1)同一类型的引用指向不同对象时,有不同的实现

                       行为的多态

               3.1.2)同一对象被造型为不同的类型的,有不同的功能

                       对象的多态

    3.2)向上造型、强制转换、instanceof

    3.3)两种表现形式:

        3.3.1)重写

               3.3.2)重载

知识点补充:

1.父类大,子类小

类型转换:

1)自动类型转换:从小到大

2)强制类型转换:从大到小

2. 设计原则:

1)将公共的特征和行为抽到父类中

2)若所有子类行为都一样,设计为普通方法

  若所有子类行为不一样,设计为抽象方法

3)符合既是也是的关系时,使用接口

3. 继承要符合is a的关系

4.   1)创建了Inter2的一个子类,没有名字

2)为该子类创建了一个对象,名为o3

3).大括号中的为该子类的类体

Inter2 o3 = new Inter2(){};

知识点巩固:

 1 1.public class Answer { 2 public static void main(String[] args) { 3  int score = 20; 4  Answer ans= new Answer(); 5   ans.add(score); 6  System.out.println(" main: score = " + score); 7  } 8 void add(int score) { 9  System.out.println(" add: score=" + score++);10  }11 }

解析:输出add: score=20

main: score =20

原因是score只定义在main函数中,作用域也是main函数,程序调用ans.add函数时,往函数中传给了参数score=20,但是这个函数没有返回值。Main函数中输出的还是变量score=20