黑马程序员 Java基础 面向对象2

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一 final关键字

1）是最终的意思，可以修饰类，方法，变量。

2）特点：

A:它修饰的类，不能被继承。

B:它修饰的方法，不能被覆盖（重写）。

C:它修饰的变量，是一个常量。

3）面试相关：

A:局部变量

a:基本类型 值不能发生改变

b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的

B:初始化时机

a:只能初始化一次。

b:常见的给值

定义的时候。(推荐)

构造方法中。

二 多态

1）多态的前提：

A:有继承或者实现关系。

B:有方法重写。

C:有父类或者父接口引用指向子类对象。

2）多态的分类：

a:具体类多态

b:抽象类多态

c:接口多态

3）多态中的成员访问特点

A:成员变量

编译看左边，运行看左边

C:成员方法

编译看左边，运行看右边

D:静态方法

编译看左边，运行看左边

为什么?

因为成员方法有重写。

 

4）案例

代码1：

/*看程序写结果 继承的时候：子类中有和父类中一样的方法，叫重写。子类中没有父亲中出现过的方法，方法就被继承过来了。*/ class A {public void show() {show2();}public void show2() {System.out.println("我");}}class B extends A {/*public void show() {show2();}*/ 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();}}

易错，当时自己就错了。输出结果是“爱你”

 

代码2：

多态继承中的内存图解

 

由这个图来想上一个例子。方法区中的Zi的函数，首先继承自父类中的函数，因为本例中子类中重写了show（）方法，所以show（）是重写后的函数。而上一例子中，show（）有的，只是是父类继承来的，不是自己写的。

 

三 抽象类

1）抽象类不能实例化。原因：调用抽象方法没有意义

 

2）抽象类的几个小问题

A：抽象类有构造函数。

虽然不能给自己的对象初始化，但是可以给自己的子类对象初始化。

B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?

为了不让创建对象

C:abstract不能和哪些关键字共存

a:final 冲突

b:private 冲突

c:static 无意义

 

3）抽象类和一般类的不同：

①一般类可以具体的描述事物。

②抽象类描述事物的信息不具体

④一般类可以创建对象，而抽象类不能创建对象。

 

4）按照多态的方式来实例化

            Animal a = new Cat();

 

5）案例：

代码1：

abstract class Animal{public abstract void eat(); public Animal(){}} class Cat extends Animal{public void eat(){System.out.println("猫吃鱼");}} public class AbstractDemo {public static void main(String[] args) {Animal a = new Cat();a.eat();}}

 

 

四 接口

1）接口的特点：

A:接口用关键字interface修饰

interface 接口名 {}

B:接口与接口

继承关系，可以单继承，也可以多继承

C:规律总结

    A:具体类多态(几乎没有)

    B:抽象类多态(常用)

    C:接口多态(最常用)

 

2）接口的成员特点：

A:成员变量

默认修饰符：public static final

B:构造方法

没有构造方法

C:成员方法

默认修饰符：public abstract

接口中的成员都是公共的。

 

3）抽象类和接口的区别(自己补齐)?

抽象类和接口的区别：

A:成员区别

抽象类：

成员变量：可以变量，也可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量

成员方法：只可以抽象

B:关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

C:设计理念区别

抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

 

4）案例

代码1：

interface Inter{public int num = 10;public final int num2 = 20;public static final int num3 = 30; // 错误// public Inter(){} public void show();} //  接口名+Impl这种格式是接口的实现类格式class InterImpl implements Inter{public void show(){}} public class InerfaceDemo2 {public static void main(String[] args) {Inter i = new InterImpl();System.out.println(i.num2);// i.num = 100;  // 无法为最终变量num分配值System.out.println(Inter.num2);}}

 

代码2：由这个来理解父类（或者说抽象类）和接口的现实意义上的区别

/*老师和学生案例,加入抽烟的额外功能分析：从具体到抽象老师：姓名，年龄，吃饭，睡觉学生：姓名，年龄，吃饭，睡觉由于有共性功能，我们提取出一个父类，人类。人类：姓名，年龄吃饭();睡觉(){}抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口抽烟接口。 部分老师抽烟：实现抽烟接口部分学生抽烟：实现抽烟接口实现：从抽象到具体使用：具体*///定义抽烟接口interface Smoking {//抽烟的抽象方法public abstract void smoke();} //定义抽象人类abstract class Person {//姓名private String name;//年龄private int age;public Person() {}public Person(String name,int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//吃饭();public abstract void eat();//睡觉(){}public void sleep() {System.out.println("睡觉觉了");}} //具体老师类class Teacher extends Person {public Teacher() {}public Teacher(String name,int age) {super(name,age);}public void eat() {System.out.println("吃大白菜");}} //具体学生类class Student extends Person {public Student() {}public Student(String name,int age) {super(name,age);}public void eat() {System.out.println("吃红烧肉");}} //抽烟的老师class SmokingTeacher extends Teacher implements Smoking {public SmokingTeacher() {}public SmokingTeacher(String name,int age) {super(name,age);} public void smoke() {System.out.println("抽烟的老师");}} //抽烟的学生class SmokingStudent extends Student implements Smoking {public SmokingStudent() {}public SmokingStudent(String name,int age) {super(name,age);} public void smoke() {System.out.println("抽烟的学生");}} class InterfaceTest2 {public static void main(String[] args) {//测试学生SmokingStudent ss = new SmokingStudent();ss.setName("林青霞");ss.setAge(27);System.out.println(ss.getName()+"---"+ss.getAge());ss.eat();ss.sleep();ss.smoke();System.out.println("-------------------");SmokingStudent ss2 = new SmokingStudent("刘意",30);System.out.println(ss2.getName()+"---"+ss2.getAge());ss2.eat();ss2.sleep();ss2.smoke();//测试老师留给自己练习}}

其实，多态等概念的实际理解，要放在后面学习的部分或者说，是在以后学习工作中，不断积累经验，丰富对它的认识的。现在理解的都很浅。

尤其可以结合以后的设计模式看。

因为面向对象思维，根本的在于用计算机或者说编程思维模拟现实世界，现实世界的逻辑是多样的，所以最终实现的手段也是多样的，所以经验很重要，才可以更好的理解多态等的思维。

 

五 包

1）其实就是文件夹

2）作用：

A:区分同名的类（同一个包下不能有同名的类）

B:对类进行分类管理

a:按照功能分

b:按照模块分

3）包的定义：

package 包名;

4）注意事项：

package语句必须在文件中的第一条有效语句
5）导包

import 包名...类名;

另一种：

import 包名...*;(不建议)

 

六 权限修饰符

1 权限修饰符

本类 同一个包下 不同包下的子类 不同包下的无关类

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

 

七 内部类

1 把类定义在另一个类的内部，该类就被称为内部类。

2 内部类的访问规则

A:可以直接访问外部类的成员，包括私有

B:外部类要想访问内部类成员，必须创建对象

class Outer{private int num = 10; class Inner{public void show(){System.out.println(num);}} public void method(){// show(); Inner i = new Inner();i.show();}}

 

3 分类（同成员变量、局部变量的分类方法）

A:成员内部类

B:局部内部类

 

4 成员内部类

A:private 为了数据的安全性

B:static 为了访问的方便性

成员内部类不是静态的：

外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

成员内部类是静态的：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

代码1：

class Body {    private class Heart {        public void operator() {            System.out.println("心脏搭桥");        }    }        public void method() {        if("你是外科医生") {            Heart h = new Heart();            h.operator();        }    }} public class InnerClassDemo4 {public static void main(String[] args) {//Body.Heart bh = new Body().new Heart();//        bh.operator();Body b =  new Body();        b.method();    }}

 

代码2：

class Outer{private int num = 10;private static int num2 = 100; public static class Inner{public void show(){//System.out.println(num); //静态内部类访问的外部类数据必须用静态修饰。System.out.println(num2);}public static void show2(){//System.out.println(num);System.out.println(num2);}}} public class InnerClassDemo4 {public static void main(String[] args) {//Outer.Inner oi = new Outer().new Inner(); 错误的访问方式//oi.show();//oi.show2();  Outer.Inner oi = new Outer.Inner(); oi.show(); oi.show2();  Outer.Inner.show2();    }}

 

5 局部内部类

A:局部内部类访问局部变量必须加final修饰。

B:为什么呢?

因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。

所以，堆内存还是用该变量，而改变量已经没有了。

为了让该值还存在，就加final修饰。

通过反编译工具我们看到，加入final后，堆内存直接存储的是值，而不是变量名。

class Outer{private int num = 10; public void method(){final int num2 = 200;class Inner{public void show(){System.out.println(num);System.out.println(num2);  // 需要被声明为最终类型}} Inner i = new Inner();i.show();}} public class InnerClassDemo5 {public static void main(String[] args) {Outer o = new Outer();o.method();}}

 

6 匿名内部类

A:是内部类的简化写法。

B:前提

存在一个类（具体类也可以是抽象类）或者接口

C:本质：

其实是继承该类或者实现接口的子类匿名对象

 

interface Inter{public abstract void show();public abstract void show2();} class Outer{public void method(){Inter i = new Inter(){ public void show() {                System.out.println("show");            }                        public void show2() {                System.out.println("show2");            }}; i.show();i.show2();}} public class InnerClassDemo6 {public static void main(String[] args) {Outer o = new Outer();o.method();}}

 

7 匿名内部类在开发中的使用

安卓开发比javaee中用到的多，因为匿名内部类使用后，就可以作为垃圾回收，不太占内存。

我们在开发的时候，会看到抽象类，或者接口作为参数。

而这个时候，我们知道实际需要的是一个子类对象。

如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

Comparator接口就是这样用的；Thread也是这样的

new Thread(new Runnable(){

}){

}.start();

 

八 面向对象三大特征：封装、继承、多态