黑马程序员---Java基础篇之面向对象

——- android培训、java培训、期待与您交流！ ———-

面向对象引入(理解)

前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。

面向对象思想概述(理解)

面向对象实际是一种思想,是一个解决实际问题的一种思想,这种思想呢就叫面向对象.A:面向过程思想概述      我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。    一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。    在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。    那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。    面向过程的代表语言：C语言B:面向对象思想概述    当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。    可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，    能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。    这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。面向过程:关注的每个步骤和过程面向对象:强调的是一个对象,然后让对象去做事情.C:面向对象思想特点    a:是一种更符合我们思想习惯的思想    b:可以将复杂的事情简单化    c:将我们从执行者变成了指挥者        角色发生了转换

面向对象思想举例(理解)

A:举例:    洗衣服    吃饭  面向对象思想是基于面向过程思想的

把大象装进冰箱案例(理解)

A:举例:    把大象装进冰箱    采用面向过程与面向对象实现B:面向过程关注步骤  面向对象关注对象  我们怎么思考才能符合面向对象思想?    A:有哪些类?    B:每个类里应该哪些东西呢?    C:类与类之间的关系是什么呢?

开发,设计和特征(了解)

A:面向对象开发    就是不断的创建对象，使用对象，指挥对象做事情。B:面向对象设计    其实就是在管理和维护对象之间的关系。C:面向对象特征    封装(encapsulation)    继承(inheritance)    多态(polymorphism)

类与对象概述(理解)

A:我们学习编程是为了什么    我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。B:我们如何描述现实世界事物    举例: 描述学生事物            姓名 , 年龄 , 性别 ....            学习 , 吃饭 , 睡觉 ....       属性: 就是该事物的描述信息    行为: 就是该事物能够做什么    我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。    由此我们就得到了现实中的事物和类的对应关系        事物                      类        属性  ----------------- 成员变量        行为  ----------------- 成员方法C:类和对象的概念    a:类：是一组相关的属性和行为的集合    b:对象：是该类事物的具体体现    c:举例：        类   学生        对象  班长就是一个对象

类的定义概述和学生类的分析(掌握)

A:类的定义  a:现实世界的事物        属性:  人的身高,体重 ...        行为:  人可以吃饭 , 睡觉 , 上课  ...  b:Java中用class描述事物也是如此    属性   -----  成员变量    行为   -----  成员方法C:定义类其实就是定义类的成员    1:成员变量  和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。    2:成员方法  和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。D:说一下学生类     属性是属于学生的特性,所以写在整个类中,表明整体学生都有这个属性.

学生类的定义(掌握)

A:学生事物    属性:  姓名 , 年龄 , 地址  ...    行为:  吃饭 , 睡觉 , 上课  ...B:学生事物与学生类的对应关系    属性   -----  成员变量    行为   -----  成员方法C:案例演示    根据分析，完成学生类代码

手机类的定义(掌握)

A:学生自己完成:   模仿学生类，让学生自己完成 手机的事物:    属性: 品牌,颜色,价格      --------- 成员变量   和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。    行为: 打电话,发短信,玩游戏 --------   成员方法  和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。B:然后讲解一遍

学生类的使用(掌握)

A:文件名问题    在一个java文件中写两个类：一个基本的类，一个测试类。    建议：文件名称和测试类名称一致。    测试类  做操作的B:如何使用呢?    创建对象使用。     how?          它就是一个变量,            变量前面写的是一个类的名字 ,所以它是一个引用类型的变量          一个引用类型的变量一定指向一个对象,new 类名();就是咱们创建出来的对象          回想起数组new 保存的是数组地址,这里也应该是对象对应的地址          既然变量保存的是一个对象的地址,那么变量名也可以称之为对象名C:如何创建对象呢?    格式：类名 对象名 = new 类名();D:如何使用成员变量呢?    格式：对象名.变量名E:如何使用成员方法呢?    格式：对象名.方法名(...)

成员变量和局部变量的区别(掌握)

Variable:变量A:在类中的位置不同    成员变量：在类中方法外    局部变量：在方法定义中或者方法声明上,定义在语句中  for循环定义在语句中,就在for循环语句中管用B:在内存中的位置不同    成员变量：在堆内存    局部变量：在栈内存C:生命周期不同  作用域不同    成员变量：随着对象的创建而存在，随着对象的消失而消失    局部变量：随着方法的调用而存在，随着方法的调用完毕而消失D:初始化值不同    成员变量：有默认初始化值    局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

方法的形式参数是类名的时候如何调用(掌握)

A:Java中参数传递问题    形式参数        基本类型：形式参数的改变不影响实际参数        引用类型：形式参数的改变直接影响实际参数B:方法的参数是类名    如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。在传递过程中,传递的是该类对象的地址值.    形式参数是基本类型 形式参数只不过是两个变量 传递的是两个具体的数值 引用类型传递的是内存的地址

匿名对象的概述和应用(理解)

A:什么是匿名对象    就是没有名字的对象B:匿名对象应用场景    a:调用方法，仅仅只调用一次的时候。         注意:调用多次的时候不适合.因为用一次就是创建了一个新的对象         好处:匿名对象调用完毕之后就是垃圾,会被垃圾回收器回收.    b:匿名对象可以作为实际参数传递   传递的时候实际是传递的内存中的地址值.(知道这个就可以了)C:案例演示    匿名对象应用场景

封装的概述(掌握)

A:封装的引入    通过学生案例，给年龄赋值为负数引出数据问题。    然后通过private解决这个问题。最后说其实这就是封装。    private:私有的.可以修饰成员变量和成员方法.B:封装概述    是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。C:封装好处    隐藏实现细节，提供公共的访问方式    提高了代码的复用性    提高安全性。D:封装原则    将不需要对外提供的内容都隐藏起来。    把属性隐藏，提供公共方法对其访问。

private关键字的概述和特点(掌握)

A:private关键字特点    a:是一个权限修饰符    b:可以修饰成员变量和成员方法    c:被其修饰的成员只能在本类中被访问B:案例演示    private关键字特点

private应用的标准案例(掌握)

A:private最常见的应用：    (1):把成员变量用private修饰   把属性隐藏起来,提供公共方法对其访问。    (2):提供对应的getXxx()和setXxx()方法  B:案例演示    演示使用封装来完善我们的学生类

this关键字的概述和应用)(掌握)

//成员变量是根据对象存在的一个变量 //调用只能通过对象去调用成员变量//这个对象如果存在,它应该代表Student的一个对象 A:为什么要有this    当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:    就是局部变量隐藏了成员变量的问题B:this关键字特点    是当前类的对象引用。    简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁C:this的应用场景    通过那个对象去调用呢?    这个对象如果存在,它应该代表Student的一个对象  那个对象调用就表示那个对象    解决局部变量隐藏成员变量D:案例演示    this的应用场景    解决局部变量成员变量重名,可以把这两个区分    this.就代表成员变量

标准的学生类代码及其测试(掌握)

A:案例演示: 把学生类的成员用private修饰,给出getXxx()/setXxx()方法###07.01_面向对象(构造方法概述和格式)(掌握)构造方法也叫构造器A:构造方法概述和作用Construct    创建对象,给对象中的成员进行初始化B:构造方法格式特点    a:方法名与类名相同    b:没有返回值类型，连void都没有    c:没有具体的返回值

构造方法的重载及注意事项(掌握)

A:案例演示    构造方法的重载B:构造方法注意事项    a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。    b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。        注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法    c:构造方法的运行特点,在new的时候运行一次 往后就不再运行.C:给成员变量赋值的两种方式    a:setXxx()方法    b:构造方法

成员方法的分类和使用(掌握)

A:类的组成:成员变量,成员方法,构造方法B:成员方法:      根据返回值类型:           void类型           非void类型      形式参数           空参方法           非空参方法

一个标准学生类的代码及测试(掌握)

A:案例演示    完善一下我们的学生的类B:给成员变量赋值：    a:setXxx()方法    b:构造方法C:输出成员变量值的方式：    a:通过getXxx()分别获取然后拼接    b:通过调用show()方法搞定

一个标准手机类的代码及测试(掌握)

A:案例演示: 模仿学生类，完成手机类代码需注意:   目前代码是为了练习的一种标准格式   给成员变量赋值有两种方式,可以只写一种   如果不单独获取数据,可以不写getXxx()方法

创建一个对象的步骤

A:画图演示    画图说明一个对象的创建过程做了哪些事情?    Student s = new Student();步骤:    (1):加载Student.class文件进内存    (2):在栈内存为s开辟空间    (3):在堆内存为学生对象开辟空间    (4):对学生对象的成员变量进行默认初始化    (5):对学生对象的成员变量进行显示初始化    (6):通过构造方法对学生对象的成员变量赋值    (7):学生对象初始化完毕，把对象地址赋值给s变量

长方形案例练习(掌握)

A:案例演示    需求：        定义一个长方形(RectangleDemo)类,定义求周长(girth)和面积(area)的方法,        然后定义一个测试类Test，进行测试。

员工类案例练习(掌握)

A:案例演示    需求：定义一个员工(Employee)类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，          以及一个显示所有成员信息的方法。并测试。

static关键字的引入(掌握)

A:案例演示    通过一个案例引入static关键字。    人类：Person。每个人都有国籍，美国。     针对多个对象共用一个成员的情况,java就提供了一个关键字static ,静态的

static关键字的特点(掌握)

A:static关键字的特点    a:随着类的加载而加载    b:优先于对象存在    c:被类的所有对象共享        举例：咱们班级的学生应该共用同一个班级编号。        其实这个特点也是在告诉我们什么时候使用静态?            如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。        举例：            饮水机(用静态修饰)            水杯(不能用静态修饰)    d:可以通过类名调用        其实它本身也可以通过对象名调用。        推荐使用类名调用。        静态修饰的内容一般我们称其为：与类相关的，类成员B:案例演示: static关键字的特点

static的注意事项(掌握)

A:static的注意事项    a:在静态方法中是没有this关键字的        如何理解呢?            静态是随着类的加载而加载，this是随着对象的创建而存在。            静态比对象先存在。    b:静态方法只能访问静态的成员变量和静态的成员方法    简单记：静态只能访问静态,非静态可以访问静态的也可以访问非静态的B:案例演示: static的注意事项

静态变量和成员变量的区别(理解)

A:所属不同    静态变量属于类，所以也称为类变量    成员变量属于对象，所以也称为实例变量(对象变量)  说什么实例化 就是指创建对象B:内存中位置不同    静态变量存储于方法区的静态区    成员变量存储于堆内存C:内存出现时间不同    静态变量随着类的加载而加载，随着类的消失而消失    成员变量随着对象的创建而存在，随着对象的消失而消失D:调用不同    静态变量可以通过类名调用，也可以通过对象调用    非静态变量只能通过对象名调用E:静态变量是对象的共享数据,非静态变量是对象的特有数据.

main方法的格式详细解释(理解)

A:格式    public static void main(String[] args) {}B:针对格式的解释    public 被jvm调用，访问权限足够大。    static 被jvm调用，不用创建对象，直接类名访问    void   被jvm调用，不需要给jvm返回值    main  一个通用的名称，虽然不是关键字，但是被jvm识别    String[] args 以前用于接收键盘录入的C:演示案例    通过args接收键盘例如数据

说明书的制作过程(理解)

A:对工具类加入文档注释    相关的一个参数执指定:    @author     指定作者    @version    指定版本    @param      指定参数    @return     指定返回值B:通过javadoc命令生成说明书    通过javadoc工具解析对应的java源文件    格式: javadoc -d 目录 -author -version 源文件名称.java    目录: 就是指定说明文档要生成的对应的文件夹

如何使用JDK提供的帮助文档(掌握)

 String  Scanner MathA:找到文档，打开文档B:点击显示，找到索引，出现输入框C:你应该知道你找谁?举例：ScannerD:看这个类的结构(需不需要导包)    java.lang包下的内容不需要我们手动导入    其它包下的内容需要我们手动导入    类                       API文档        成员变量                字段摘要        构造方法                构造方法摘要        成员方法                方法摘要E:看这个类的说明(简单的了解一下)F:看开始版本G:看构造方法H:看成员方法    看左边:        是否是static的,如果是我们就不需要创建对象,直接可以使用类名调用该方法;看返回值,返回值是什么我就使用什么接收    看右边:        看参数列表: 参数的个数 , 参数的类型 ; 要什么参数我是用的时候,就传递什么参数                  I:然后使用

学习Math类的随机数功能(掌握)

打开JDK提供的帮助文档学习A:Math类概述    类包含用于执行基本数学运算的方法B:Math类特点    由于Math类在java.lang包下，所以不需要导包。    没有构造方法，因为它的成员全部是静态的。C:获取随机数的方法    public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。D:我要获取一个1-100之间的随机数，肿么办?    int number = (int)(Math.random()*100)+1;

猜数字小游戏案例(理解)

A:案例演示    需求：猜数字小游戏(数据在1-100之间)    ###08.01_面向对象(代码块的概述和分类)(理解) 你要能知道别人代码里写了这些东西 是干什么用的,以及执行顺序A:代码块概述    在Java中，使用{}括起来的代码被称为代码块。B:代码块分类    根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。C:常见代码块的应用    a:局部代码块         在方法中出现；限定变量生命周期，及早释放，提高内存利用率    b:构造代码块         在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行    c:静态代码块         在类中方法外出现，加了static修饰        在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

代码块的面试题(理解)

A:看程序写结果    class Student {        static {            System.out.println("Student 静态代码块");        }        {            System.out.println("Student 构造代码块");        }        public Student() {            System.out.println("Student 构造方法");        }    }    class StudentDemo {        static {            System.out.println("StudentDemo的静态代码块");        }        public static void main(String[] args) {            System.out.println("我是main方法");            Student s1 = new Student();            Student s2 = new Student();        }    }

继承的引入和概述(掌握)

A:继承概述    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。B:继承格式    通过extends关键字可以实现类与类的继承    class 子类名 extends 父类名 {}      单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。    有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员.

继承案例演示以及继承的好处和弊端(掌握)

 代码名称:ExtendsDemo.javaA:需求：    学生类和老师类。    定义两个功能(吃饭，睡觉)B:案例演示    使用继承前C:案例演示    使用继承后D:继承的好处    a:提高了代码的复用性    b:提高了代码的维护性    c:让类与类之间产生了关系，是多态的前提E:继承的弊端(了解)    类的耦合性增强了。    开发的原则：高内聚，低耦合。    耦合：类与类的关系    内聚：就是自己完成某件事情的能力

Java中类的继承特点(掌握)

A:Java中类的继承特点    a:Java只支持单继承，不支持多继承。        有些语言是支持多继承，格式：extends 类1,类2,...    b:Java支持多层继承(继承体系)B:案例演示    Java中类的继承特点

继承的注意事项和什么时候使用继承(掌握)

代码名称:ExtendsDemo3.java
A:继承的注意事项
a:子类只能继承父类所有非私有的成员(成员方法和成员变量) 被private修饰的成员只能在本类使用
b:子类不能继承父类的构造方法，但是可以通过super(待会儿讲)关键字去访问父类构造方法。
c:不要为了部分功能而去继承
B:什么时候使用继承
继承其实体现的是一种关系：”is a” .
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

继承中成员变量的关系(掌握)

代码名称:ExtendsDemo4.javaA:子类中的成员变量和父类中的成员变量名称不一样B:子类中的成员变量和父类中的成员变量名称一样    在子类中访问一个变量的查找顺序("就近原则")        a: 在子类的方法的局部范围找,有就使用        b: 在子类的成员范围找,有就使用        c: 在父类的成员范围找,有就使用        d:如果还找不到,就报错

this和super的区别和应用(掌握) (搞清楚this可以调用本类中的成员方法,成员变量,构造方法 ) 代码名称:ExtendsDemo5.java

                                              (搞清楚super可以调用父类中的成员方法,成员变量,构造方法 )A:通过问题引出super    子类局部范围访问父类成员变量B:说说this和super的区别    this代表的是本类对象的引用    super代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)C:this和super的使用    a:调用成员变量        this.成员变量   调用本类的成员变量        super.成员变量  调用父类的成员变量    b:调用构造方法        this(...)           调用本类的构造方法        super(...)          调用父类的构造方法    c:调用成员方法        this.成员方法()     调用本类的成员方法        super.成员方法()    调用父类的成员方法    注意：b，c马上讲

继承中构造方法的关系(掌握)(在子类做初始化的时候一定先对父类进行初始化,所以子类构造默认有super())

代码名称:ExtendsDemo6.javaA:案例演示    子类中所有的构造方法默认都会访问父类中空参数的构造方法B:为什么呢?    因为子类会继承父类中的数据，可能还会使用父类的数据。    所以，子类初始化之前，一定要先完成父类数据的初始化。    其实：(了解)        每一个构造方法的第一条语句默认都是：super()        在这里简单的提一句，Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。

继承中构造方法的注意事项(掌握)

代码名称:ExtendsDemo7.javaA:案例演示    父类没有无参构造方法,子类怎么办?    a: 在父类中添加一个无参的构造方法    b:子类通过super去调用父类其他的带参的构造方法 ---------------(要懂得怎么用)    c:子类通过this去调用本类的其他构造方法        本类其他构造也必须首先访问了父类构造B:注意事项    super(…)或者this(….)必须出现在第一条语句上    如果是不放在第一句上,就可以出现对父类的数据进行多次初始化,所以必须放在第一句

继承中的面试题(掌握)

A:案例演示    看程序写结果1    class Fu{        public int num = 10;        public Fu(){            System.out.println("fu");        }    }    class Zi extends Fu{        public int num = 20;        public Zi(){            System.out.println("zi");        }        public void show(){            int num = 30;            System.out.println(num);            System.out.println(this.num);            System.out.println(super.num);        }    }    class Test {        public static void main(String[] args) {            Zi z = new Zi();            z.show();        }    }B:案例演示   加载子类的时候要先加载父类    看程序写结果2    class Fu {        static {            System.out.println("静态代码块Fu");        }        {            System.out.println("构造代码块Fu");        }        public Fu() {            System.out.println("构造方法Fu");        }    }    class Zi extends Fu {        static {            System.out.println("静态代码块Zi");        }        {            System.out.println("构造代码块Zi");        }        public Zi() {            System.out.println("构造方法Zi");        }    }    Zi z = new Zi(); 请执行结果。

继承中成员方法关系(掌握)

代码名称:ExtendsDemo8.java
A:案例演示
a:当子类的方法名和父类的方法名不一样的时候
b:当子类的方法名和父类的方法名一样的时候
通过子类调用方法:
a: 先查找子类中有没有该方法,如果有就使用
b:在看父类中有没有该方法,有就使用
c: 如果没有就报错

方法重写概述及其应用(掌握)

代码名称:ExtendsDemo9.javaA:什么是方法重写    子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。B:方法重写的应用：    当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。    这样，即沿袭了父类的功能，又定义了子类特有的内容。C:案例演示    a:定义一个手机类。    b:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。

方法重写的注意事项(掌握)(记住这几个注意事项,写程序的时候记住不重写父类的私有,重写的时候权限保持一致,最好声明是一模一样包括(static))

代码名称:ExtendsDemo10.java
A:方法重写注意事项
a:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
b:子类重写父类方法时，访问权限不能更低
最好就一致
c:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

    子类重写父类方法的时候，最好声明一模一样。B:案例演示    方法重写注意事项

方法重写的面试题的面试题(掌握)

A:方法重写的面试题    Override和Overload的区别?Overload能改变返回值类型吗?

使用继承前的学生和老师案例(掌握)

A:案例演示: 使用继承前的学生和老师案例

使用继承后的学生和老师案例(掌握)

A:案例演示: 使用继承后的学生和老师案例

猫狗案例分析,实现及测试(掌握)

A:猫狗案例分析    父类的由来:  首先我们需要分析具体的事物,分析完毕以后将共性的内容提取出来放在一个独立的类中(父类).B:案例演示    猫狗案例继承版

final关键字概述(掌握)

A:为什么会有final    由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: finalB:final概述    final关键字是最终的意思，可以修饰类，变量，成员方法。

final关键字修饰类,方法以及变量的特点(掌握)

A:final修饰特点    修饰类:        被修饰类不能被继承    修饰方法:   被修饰的方法不能被重写    修饰变量:   被修饰的变量不能被重新赋值,因为这个量其实是一个常量B:案例演示    final修饰特点

final关键字修饰局部变量(掌握)

A:案例演示      基本类型，是数值不能被改变    引用类型，是地址值不能被改变

final修饰成员变量的初始化时机(掌握)

A:final修饰变量的初始化时机    a: 被final修饰的变量只能赋值一次    b:在构造方法完毕前即可(非静态的常量)B:案例演示    final修饰变量的初始化时机    ###09.01_面向对象(多态的概述及其代码体现)(掌握)A:多态概述    某一个事物，在不同时刻表现出来的不同状态。  水(气态,液态,固态)    举例：        猫可以是猫的类型。猫 m = new 猫();        同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();B:多态前提    a:要有继承关系。    b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。    c:要有父类引用指向子类对象。        父 f =  new 子();  C:案例演示: 代码体现多态

多态中的成员访问特点(掌握)(重点 !记住成员方法,运行看右边)

A:多态中的成员访问特点    a:成员变量        编译看左边，运行看左边。    b:构造方法        创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。    c:成员方法        编译看左边，运行看右边。    d:静态方法        编译看左边，运行看左边。        (静态和类相关，算不上重写，所以，访问还是左边的)B:案例演示    多态中的成员访问特点

多态的好处和弊端(理解)

A:多态的好处    a:提高了代码的维护性(继承保证)    b:提高了代码的扩展性(由多态保证)B:案例演示: 多态的好处  动物吃睡玩D:案例演示: 多态的弊端

多态中向上转型和向下转型(掌握)(注意 父类的引用必须是指向该转换的子类的对象)

A:通过多态的弊端引出问题    不能使用子类特有的功能B:解决问题    a:把父类的引用强制转换为子类的引用。(向下转型)C:案例演示    详细讲解多态中向上转型和向下转型

多态中的题目分析题(掌握)

A:看下面程序是否有问题，如果没有，说出结果    class Fu {        public void show() {            System.out.println("fu show");        }    }    class Zi extends Fu {        public void show() {            System.out.println("zi show");        }        public void method() {            System.out.println("zi method");        }    }    class DuoTaiTest3 {        public static void main(String[] args) {            Fu f = new Zi();            f.method();            f.show();        }    }B:看下面程序是否有问题，如果没有，说出结果    class A {        public void show() {            show2();        }        public void show2() {            System.out.println("我");        }    }    class B extends A {        public void show2() {            System.out.println("爱");        }    }    class C extends B {        public void show() {            super.show();        }        public void show2() {            System.out.println("你");        }    }    public class DuoTaiTest4 {        public static void main(String[] args) {            A a = new B();            a.show();            B b = new C();            b.show();        }    }

抽象类的概述及其特点(掌握)(掌握格式,记住一句话 如果类中有抽象方法,那么该类必须是抽象类)

A:抽象类概述    回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。        为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。     所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。    同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。    在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。B:抽象类特点    a:抽象类和抽象方法必须用abstract关键字修饰        抽象类格式:      abstract class 类名 {}        抽象方法格式: public abstract 返回值类型 方法名();    b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类    c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?        用于子类访问父类数据时的初始化    d:抽象类不能实例化那么，抽象类如何实例化呢?        按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。    e:抽象类的子类        要么是抽象类        要么重写抽象类中的所有抽象方法的具体类C:案例演示    抽象类特点

抽象类的成员特点(掌握)

A:抽象类的成员特点    a:成员变量：既可以是变量，也可以是常量。    b:构造方法：有。                用于子类访问父类数据的初始化。    c:成员方法：既可以是抽象的，也可以是非抽象的。B:案例演示    抽象类的成员特点C:抽象类的成员方法特性：    a:抽象方法      强制要求子类做的事情。    b:非抽象方法     子类继承的事情，提高代码复用性。

抽象类练习猫狗案例(掌握)

A:案例演示    具体事物：猫，狗    共性：姓名，年龄，吃饭

抽象类练习老师案例(掌握)

A:案例演示    具体事物：基础班老师，就业班老师    共性：姓名，年龄，讲课。

抽象类练习员工案例(掌握)

A:案例演示    假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。    经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。    然后定义工作的方法.    请使用继承的思想设计出员工类和经理类。

抽象类中的面试题(掌握)

A:面试题1    一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?    答案: 可以 . 不能创建对象.B:面试题2    abstract不能和哪些关键字共存?        private    冲突        final      冲突        static     无意义

接口的概述及其特点(掌握)

杂技 AcrobaticsA:接口概述    继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。    但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。    而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。    所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。    所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可B:接口特点    a:接口用关键字interface表示      格式:    interface 接口名 {}    b:类实现接口用implements表示     格式:    class 类名 implements 接口名 {}    c:接口不能实例化        那么，接口如何实例化呢?        按照多态的方式来实例化。    d:接口的子类        a:可以是抽象类。但是意义不大。        b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)C:案例演示    接口特点

接口的成员特点(掌握)

A:接口成员特点    成员变量；只能是最终变量，并且是静态的。            默认修饰符：public static final            建议：自己手动给出。    构造方法：接口没有构造方法。    成员方法：只能是抽象方法。            默认修饰符：public abstract            建议：自己手动给出。B:案例演示: 接口成员特点

类与类,类与接口,接口与接口的关系(掌握)

A:类与类,类与接口,接口与接口的关系    a:类与类：        继承关系,只能单继承,可以多层继承。    b:类与接口：        实现关系,可以单实现,也可以多实现。        并且还可以在继承一个类的同时实现多个接口。    c:接口与接口：        继承关系,可以单继承,也可以多继承。B:案例演示    类与类,类与接口,接口与接口的关系

抽象类和接口的区别(掌握)

A:成员区别    抽象类：        成员变量：可以变量，也可以常量        构造方法：有        成员方法：可以抽象，也可以非抽象    接口：        成员变量：只可以常量        成员方法：只可以抽象  B:关系区别    类与类        继承，单继承    类与接口        实现，单实现，多实现    接口与接口        继承，单继承，多继承  C:设计理念区别    抽象类     被继承体现的是：”is a”的关系。  抽象类中定义的是该继承体系的共性功能。    接口  被实现体现的是：”like a”的关系。    接口中定义的是该继承体系的扩展功能。

猫狗案例加入跳高功能分析及其代码实现(掌握)

A:案例演示    动物类：姓名，年龄，吃饭，睡觉。    动物培训接口：跳高    猫继承动物类    狗继承动物类    部分猫继承猫类并实现跳高接口    部分狗继承狗类并实现跳高接口    通过抽象类测试基本功能。    通过接口测试扩展功能。    只测试猫，狗的测试留给学生自己练习   

运动员和教练案例分析(掌握)

A:案例分析    教练和运动员案例(学生分析然后讲解)    乒乓球运动员和篮球运动员。    乒乓球教练和篮球教练。    为了出国交流，跟乒乓球相关的人员都需要学习英语。    请用所学知识：    分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

运动员和教练案例实现(掌握)

A:案例演示: 运动员和教练的代码实现

运动员和教练案例分析(掌握)

A:案例分析    教练和运动员案例(学生分析然后讲解)    乒乓球运动员和篮球运动员。    乒乓球教练和篮球教练。    为了出国交流，跟乒乓球相关的人员都需要学习英语。    请用所学知识：    分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

运动员和教练案例实现(掌握)

A:案例演示: 运动员和教练的代码实现

类名作为形式参数(掌握)

 形式参数:       基本数据类型 传递的该变量的数值       引用数据类型 传递的是地址值,其实就是一个对象A:案例演示: 类名作为形式参数            传递的是该类的对象

抽象类名作为形式参数(掌握)

A:案例演示: 抽象类名作为形式参数            传递的是该抽象类的子类对象

接口名作为形式参数(掌握)

A:案例演示: 接口名作为形式参数            传递的是实现该接口的类的对象

类名作为返回值类型(掌握)

A:案例演示: 类名作为返回值类型            返回的是该类对象

抽象类名作为返回值类型(掌握)

A:案例演示: 抽象类名作为返回值类型            返回的是子类对象

接口名作为返回值类型(掌握)

A:案例演示: 接口名作为返回值类型            返回的是该实现类的对象

链式编程(掌握)

A:案例演示: 链式编程

package关键字的概述及作用(了解)

A:包的概述:  就是文件夹B:包的作用:   用来解决同一个路径下不能存在同名文件的问题(分类管理)C:包的划分:    按照功能    按照模块

包的定义及注意事项(了解)

A:定义包的格式    package 包名;    多级包用.分开即可B:定义包的注意事项    A:package语句必须是程序的第一条可执行的代码    B:package语句在一个java文件中只能有一个    C:如果没有package，默认表示无包名C:案例演示    包的定义及注意事项

带包的类编译和运行(了解)

A:手动式    a:javac编译当前类文件。    b:手动建立包对应的文件夹。    c:把a步骤的class文件放到b步骤的最终文件夹下。    d:通过java命令执行。注意了：需要带包名称的执行    java cn.itcast.HelloWorldB:自动式    a:javac编译的时候带上-d即可    javac -d . HelloWorld.java    b:通过java命令执行。和手动式一样

不同包下类之间的访问(了解)

A:案例演示    都需要加包的全路径    不同包下类之间的访问        定义两个类：Demo,Test。            Demo                求和方法(sum)            Test                测试方法(main)

import关键字的概述和使用(了解)

A:导包的概述    不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能B:导包格式    import 包名.类名;    注意：        这种方式导入是到类的名称。        虽然可以最后写*，但是不建议。C:package,import,class有没有顺序关系(面试题)  有 package在可执行语句的第一句  import在class上面  class

四种权限修饰符的测试(了解)

A:案例演示    四种权限修饰符: private(私有的)  , 默认 , protected(受保护的) , public(公共的) B:结论                本类     同一个包下(子类和无关类)        不同包下(子类)    不同包下(无关类)    private     Y           默认          Y        Y    protected   Y        Y                             Y    public      Y        Y                             Y                Y

类及其组成所使用的常见修饰符(理解)

A:修饰符：    权限修饰符：private，默认的，protected，public    状态修饰符：static，final    抽象修饰符：abstractB:类：    权限修饰符：默认修饰符，public    状态修饰符：final    抽象修饰符：abstract    用的最多的就是：publicC:成员变量：    权限修饰符：private，默认的，protected，public    状态修饰符：static，final    用的最多的就是：privateD:构造方法：    权限修饰符：private，默认的，protected，public    用的最多的就是：publicE:成员方法：    权限修饰符：private，默认的，protected，public    状态修饰符：static，final    抽象修饰符：abstract    用的最多的就是：publicF:除此以外的组合规则：    成员变量：public static final    成员方法：public static              public abstract             public final

内部类概述和访问特点(理解)

A:内部类概述:    把类定义在其他类的内部，这个类就被称为内部类。    举例：在类A中定义了一个类B，类B就是内部类。B:内部类访问特点    a:内部类可以直接访问外部类的成员，包括私有。    b:外部类要访问内部类的成员，必须创建对象。C:案例演示    内部类极其访问特点

内部类分类及成员内部类的直接使用(理解)

A:按照内部类位置分类    成员位置:在成员位置定义的类，被称为成员内部类。        局部位置:在局部位置定义的类，被称为局部内部类。B:成员内部类    如何在测试类中直接访问内部类的成员。    格式:     外部类名.内部类名 对象名 = 外部类对象.内部类对象;

成员内部类的常见修饰符及应用(理解)

A:成员内部类的修饰符：    private     为了保证数据的安全性    static  为了方便访问数据        注意事项:   a: 静态内部类访问的外部类数据必须用静态修饰。                   b: 成员方法可以是静态的也可以是非静态的B:成员内部类被静态修饰后的访问方式是:    格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();

成员内部类的面试题(理解)

A:面试题    要求：使用已知的变量，在控制台输出30，20，10。    interface Arry{         public int num = 5   }    class Outer {        public int num = 10;        class Inner {            public int num = 20;            public void show() {                int num = 30;                System.out.println(num);  //30                System.out.println(this.num);  //20                System.out.println(Outer.this.num);//10                System.out.println(Outer.super.unm);//5            }        }    }    class InnerClassTest {        public static void main(String[] args) {            Outer.Inner oi = new Outer().new Inner();            oi.show();        }       }

局部内部类访问局部变量的问题(理解)

A: 可以直接访问外部类的成员B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能C: 局部内部类访问局部变量必须用final修饰   为什么呢?    因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。    为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。    局部内部类只能访问被final修饰的局部变量。

匿名内部类的格式和理解以及匿名内部类的方法调用(理解)

A:匿名内部类:        就是内部类的简化写法。B:前提：           存在一个类或者接口;这里的类可以是具体类也可以是抽象类。C:格式：    new 类名或者接口名(){        重写方法;    };D:本质是什么呢?    是一个继承了该类或者实现了该接口的子类匿名对象。E:案例演示    按照要求来一个匿名内部类F:案例演示: 匿名内部类的方法调用

匿名内部类在开发中的应用(理解)

A:问题引出    首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，    我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，    所以，可以使用匿名内部类改进以前的做法。B:代码如下    //这里写抽象类，接口都行    abstract class Person {        public abstract void show();    }    class PersonDemo {        public void method(Person p) {            p.show();        }    }    class PersonTest {        public static void main(String[] args) {            //如何调用PersonDemo中的method方法呢?        }    }

匿名内部类的面试题

A:面试题    按照要求，补齐代码    interface Inter { void show(); }    class Outer { //补齐代码 }    class OuterDemo {        public static void main(String[] args) {              Outer.method().show();          }    }    要求在控制台输出”HelloWorld”

——- android培训、java培训、期待与您交流！ ———-