黑马程序员技术交流社区

标题: 面向对象知识点总结，每天更新（正在学习ing） [打印本页]

作者: 窗外的雪儿飞 时间: 2015-8-28 23:29
标题: 面向对象知识点总结，每天更新（正在学习ing）
1：面向对象(理解)
(1)面向对象是相对应面向过程而言的一种编程思想，是基于面向过程的。
(2)思想特点：
  A:是一种更符合我们思考习惯的思想。
  B:把复杂的事情简单化。
  C:让我们从执行着变成了指挥者。
(3)案例：
  A:买电脑
  B:吃饭，洗衣服
  C:我要喝水
(4)把大象装进冰箱，让大家对面向对象有一点点的了解。
  面向过程：
class Demo {
public static void main(String[] args) {
   open();
   in();
   close();
}
public static void open() {
   System.out.println("开门");
}
public static void in() {
   System.out.println("我要进去");
}
public static void close() {
   System.out.println("关门");
}
}
  面向对象：
如何让我们的代码更符合面向对象思想
A:有哪些类
B:类有哪些功能
C:类与类的关系
class 大象 {
public void in() {
   System.out.println("我要进去");
}
}
class 冰箱 {
public void open() {
   System.out.println("开门");
}
public void close() {
   System.out.println("关门");
}
}
class Test {
public static void main(String[] args) {
   冰箱 b = new 冰箱();
   大象 d = new 大象();
   b.open();
   d.in();
   b.close();
}
}
2：类与对象的关系(掌握)
(1)现实世界的事物：
  属性：事物的特征
  行为：事物的功能
(2)java中最基本的单位是类。所以，我们要把事物转换为对应的类。
(3)如何转换呢：
  类  事物
  成员变量属性
  成员方法行为
  成员变量：属性，字段
  成员方法：函数，方法
(4)类与对象的概念
  类：是一组相关的属性和行为的抽象的集合体。
  对象：是该类事物的具体存在的个体。
  类：学生
  对象：林青霞
3：类与对象的使用(掌握)
(1)学生类的制作和使用
(2)手机类的制作和使用
4：内存图(理解)
(1)一个对象的内存图：
  一个对象的基本初始化过程。
(2)二个对象的内存图：
  方法的共用。
(3)三个对象的内存图：
  两个引用变量指向同一个对象。
5：成员变量和局部变量的区别?
(1)在类中的位置不同：
  成员变量：类中方法外。
  局部变量：方法中或者方法声明上。
(2)在内存中的位置不同：
  成员变量：堆中。
  局部变量：栈中。
(3)生命周期不同：
  成员变量：随着对象的存在而存在，随着对象的消失而消失。
  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
(4)初始化值不同；
  成员变量：有默认初始化值。
  局部变量：没有默认初始化值。
问题：
  成员变量和名称可以不可和局部变量一样呢?
可以。
  class Demo {
int x = 10;
public void show() {
int x = 20;
System.out.println(x);
}
public void method() {
System.out.println(x);
}
  }

作者: 窗外的雪儿飞 时间: 2015-8-28 23:31
1:变量什么时候该定义成员变量(掌握)
(1)如果变量和类之间存在这描述性的关系，就该定义为成员变量。
(2)注意：
  变量的定义范围越小越好。
2:引用类型作为形式参数和返回值(掌握)
(1)顾客点菜案例。
  顾客--服务员--厨师
(2)引用类型作为参数和返回值的问题：
  A:如果一个方法的形式参数是一个类名，那么，这里肯定需要的是该类的对象。
  B:如果一个方法的返回值是一个类名，那么，这里返回的肯定是该类的对象。
  class Demo {
public void printStudent(Student s) {
s.show();
}
public Student getStudent() {
Student s = new Student();
return s;
}
  }
3:匿名对象(理解)
(1)就是没有名字的对象。
(2)应用场景：
  A:调用方法。但是仅仅只调用一次的时候使用。
  B:作为实际参数传递。
Demo d = new Demo();
d.printStudent(new Student());
4:封装(理解)
(1)隐藏实现细节，提供公共的访问方式。
(2)体现有哪些呢?
  A:类
  B:方法体
  C:private修饰成员变量
(3)private关键字：
  是私有的意思。可以修饰类中的成员变量和成员方法。
  注意：被它修饰的成员只能在本类中被访问。
(4)标准代码：
  class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
  }
5:构造方法(掌握)
(1)创建对象，并对对象的内容进行初始化。
(2)特点：
  A:方法名和类名相同。
  B:没有返回值类型。
  C:没有返回值。
(3)注意事项：
  A:如果我们没给构造方法，系统给出一个默认构造。无参构造。
  B:如果我们给出了构造方法，系统将不再提供构造方法。
这个时候，要么我们不使用无参构造方法。
要么，自己定义一个，然后使用。
推荐：自己给出无参构造方法。
(4)给成员变量赋值的方式：
  A:无参+setXxx()
  B:带参
(5)获取值：
  getXxx()
(6)标准代码：
  class Student {
private String name;
private int age;
public Student() {}
public Student(String n,int a) {
name = n;
age = a;
}
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
  }
6：this关键字。(掌握)
(1)代表当前类的一个对象。谁调用代表谁。
(2)应用场景：
  A:使用本类的成员变量(掌握)
this.变量名;
  B:使用本类其他构造方法
this(...)
  C:使用本类的其他成员方法
this.方法名();
(3)标准代码：
  class Student {
private String name;
private int age;
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
  }
  测试类：
Student s = new Student();
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName()+"---"+s.getAge());
Student ss = new Student("林青霞",27);
System.out.println(ss.getName()+"---"+ss.getAge());
(4)案例：
  A:手机标准代码案例及测试。
  B:长方形标准代码案例及测试。
7：static关键字(理解)
(1)是静态的意思，可以修饰类中成员变量和成员方法。
(2)静态的特点：
  A:随着类的加载而加载。
  B:优先于对象存在。
  C:被所有对象共享的数据。
这个也被我们作为为什么要使用静态的一个判断条件。
举例：饮水机和水杯。
  D:让我们的调用多了一种方式：
a:非静态的数据，必须创建对象访问。
b:静态的数据，可以通过对象访问，也可以通过类名访问。
(3)静态的访问问题：
  A:非静态方法
非静态成员变量
静态成员变量
非静态成员方法
静态成员方法
  B:静态方法
静态成员变量
静态成员方法
  总之：静态只能访问静态。
  称呼：
静态的成员被成为类成员。跟类相关。
非静态的成员被称为实例成员。跟对象相关。
(4)main方法的解释以及如何接收键盘录入数据：
  public:权限最大
  static:静态，不用创建对象。
  void:返回没有意义。
  main:大家都是这样做的。
  String[] args:接收键盘录入数据。
  接收键盘录入的格式：
java HelloWorld hello world java
java HelloWorld 10 20 30
8：代码块(理解)
(1)用{}括起来的代码。
(2)分类：
  A:局部代码块。
方法内。
作用：限定变量的生命周期，提高效率。
  B:构造代码块。
类中，方法外。
作用：把所有构造方法中相同的代码定义到一处。
  C:静态代码块。
类中，方法外，加static。
作用：在整个系统运行过程中只执行一次的内容。
(3)面试题：
  构造方法，构造代码块，静态代码块的执行流程?
  静态代码块 -- 构造代码块 -- 构造方法。
  特点：
静态代码块只执行一次。
构造代码块每次调用构造方法都执行。
9：一个类的实例化过程(理解)
Person p = new Person();
A:把Person.class加载到内存。
B:在栈内存为p变量开辟空间。
C:在堆内存为Person对象开辟空间。
D:对成员变量进行默认初始化。
E:对成员变量进行显示初始化。
F:如果有构造代码块，通过构造代码块对成员变量进行初始化。
G:通过构造方法对成员变量进行初始化。
I:对象初始化完毕，把堆内存的地址给p变量。

作者: 微笑的背后3 时间: 2015-8-29 00:28
加油

作者: 窗外的雪儿飞 时间: 2015-8-29 21:11

微笑的背后3 发表于 2015-8-29 00:28
加油

谢谢

作者: 窗外的雪儿飞 时间: 2015-8-29 21:24
【总结】

1，静态方法。
目标：必须要理解什么时候用静态修饰方法。
我的理解：自己写。

2，主函数。

3，静态变量。目标：必须要理解什么时候用静态修饰成员变量
理解：成员变量和局部变量的区别。

4，静态代码块。
了解：它的作用，以及加载执行的过程就可以了。

5，构造代码块
了解：它的作用，以及执行的顺序。

对象创建过程:
1，加载指定类。
2，将静态变量默认初始化，显示初始化。
3，静态代码块初始化。
4，new在堆内存中开辟空间，明确首地址值。
5，对象中的成员变量进行默认初始化。
6，调用对应的构造函数。
6.1 super()调用父类的构造函数。
6.2 成员变量的显示初始化。
6.3 构造代码块初始化。
6.4 构造函数自定义内容的初始化。

6，单例设计模式。
目标：
1，解决的问题？★★★★★
对象的唯一性的问题。
2，场景是什么？
多应用程序可以实现数据共享交换。
3，思路是什么？★★★★★

4，步骤和代码体现？要求明确每一个关键字为什么出现！★★★★★
5，饿汉式和懒汉式的区别？要求画图★★★★★
6，自己写一个超人的单例。

7，继承：
1，继承的好处。★★★★★
2，Java中的单继承和多继承的区别，以及多继承的好处，为什么不直接支持？★★★★★
多继承好处：更加的扩展了子类的功能。这个机制非常好。
但是有弊端：导致调用多父类中的相同功能时，出现调用的不确定性。

3，对于继承体系，应该怎么学习？★★★★★
参阅顶层类，使用底层类。
8、对象的初始化过程。
/*
1，加载Demo.class文件进方法区，并进行空间分配。
2，如果有静态变量，先默认初始化，显示初始化。
3，如果有静态代码块，要执行，仅一次。
4，通过new在堆内存中开辟空间，并明确首地址。
5，对对象中的属性进行默认初始化。
6，调用对应的构造函数进行初始化。
7，构造函数内部。
7.1 调用父类构造函数super();
7.2 成员变量的显示初始化。
7.3 构造代码块初始化。
7.4 构造函数内容自定义内容初始化。
8，对象初始化完毕后，将地址赋值给d引用变量。

*/
9、/*
继承出现后，在代码中的体现

重点在在于成员的体现：
1，成员变量。重点明确原理。
特殊情况：
子父类中定义了一模一样的成员变量。
都存在于子类对象中。
如何在子类中直接访问同名的父类中的变量呢？
通过关键字 super来完成。

super和this的用法很相似。
this：代表的是本类的对象的引用。
super：代表的是父类的内存空间。

注意：这种情况开发见不到，因为父类一旦描述完了属性，子类直接使用就可以了。
【子父类中成员函数的特点】
特殊情况：
子父类中的定义了一模一样的函数。
运行的结果:子类的函数在运行。
这种情况在子父类中，是函数的另一个特性：override(重写，覆盖，复写)
【重写(覆盖)的注意事项】

1，子类覆盖父类，必须保证全要大于或者等于父类的权限。
Fu:
private void show(){}

Zi:
public void show(){}
2，静态覆盖静态。

写法上稍微注意:必须一模一样:函数的返回值类型函数名参数列表都要一样。

【总结】
当一个类是另一个类中的一种时，可以通过继承，来扩展功能。
如果从父类具备的功能内容需要子类特殊定义时，使用重写。
【子父类中构造函数的特点】
当子父类都有构造函数时，发现结果为：
fu constructor run
zi constructor run
先执行了父类的构造函数，再执行子类的构造函数。

【这是为啥呢？】
因为子类的所有的构造函数中的第一行都有一句隐式语句 super(); //默认调用的是父类中的空参数的构造函数。

【子类中的构造函数为什么有一句隐式的super()呢？】
原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。
才可以更方便的使用父类中的内容。

【小结】
当父类中没有空参数构造函数时，子类的构造函数必须同构显示的super语句指定要访问的父类中的构造函数。
这就是传说中的子类实例化过程。

【实例化过程的细节】
1，如果子类的构造函数第一行写了this调用了本类其他构造函数，那么super调用父类的语句还有吗？
没有的，因为this()或者super(),只能定义在构造函数的第一行，因为初始化动作要先执行。

2，父类构造函数中是否有隐式的super呢？
也是有的。记住：只要是构造函数默认第一行都是super();
父类的父类是谁呢？super调用的到底是谁的构造函数呢？
Java体系在设计，定义了一个所有对象的父类Object ，

【总结】
类中的构造函数默认第一行都有隐式的super()语句，在访问父类中的构造函数。
所以父类的构造函数既可以给自己的对象初始化，也可以给自己的子类对象初始化。

如果默认的隐式super语句没有对应的构造函数，必须在构造函数中通过this或者super的形式明确调用的构造函数。

【问题】
1，this语句和super语句是否可以在同一个构造函数中出现呢？不行，因为必须定义在第一行。
2，为什么要定义在第一行呢？因为初始化动作要先执行。
/*
继承的弊端：打破封装性。
不让其他类继承该类，就不会有重写。
怎么能实现呢？通过Java中的一个关键字来实现，final(最终化)。

【final关键字】
是一个修饰符，可以修饰类，方法，变量(成员变量，局部变量，静态变量)。
【特点】
1，final修饰的类是一个最终类，不能在派生子类。
如果类中从出现部分可以重写，部分不可以？怎么办？只要让指定的方法最终化就可以了。
2，final修饰的方法是最终方法，不可以给重写。
3，final修饰的变量是一个常量，只能被赋值一次。
【什么时候会在程序中定义final常量呢？】
当程序中一个数据使用时是固定不变的，这时为了增加阅读性，可以该该数据起个名字。
这就是变量，为了保证这个变量的值不被修改，加上final修饰，这就一个阅读性很强的常量。
书写规范，被final修饰的常量名所有的字母都是大写的。如果由多个单词组成单词间通过 _ 连接。

作者: 窗外的雪儿飞 时间: 2015-9-1 22:14
1：final(掌握)
(1)是一个关键字，表示的是最终的意思。
(2)它可以修饰类，修饰成员变量，修饰成员方法。
(3)特点：
它修饰的类不能被继承。
它修饰的变量是常量。
它修饰的成员方法不能被重写。
(4)面试题：
修饰局部变量。

方法的形式参数：
基本类型：基本类型的值不能发生改变。
引用类型：引用类型的地址值不能发生改变，但是内容可以发生改变。

2：多态(掌握)
(1)同一个对象在不同时刻表现出现的多种状态。
举例：
水(水蒸气,冰,水)
理解：
编译时期状态和运行时期状态不一致的现象。

判断下面哪个有问题：从右边往左边念。
Fu f = new Fu();
Zi z = new Zi();
Fu f = new Zi(); //多态
Zi z = new Fu(); //报错
(2)多态的前提：
A:要有继承或者实现关系。
B:有方法重写。
因为一般都是抽象类或者接口的多态。
C:要有父类/父接口的引用指向子类对象。
(3)多态访问的成员特点：
Fu f = new Zi();

A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。
C:静态方法
编译看左边，运行看左边。
(4)多态的好处和弊端：
A:好处
提高了程序的可维护性和可扩展性。
维护性：继承保证
扩展性：多态保证
B:弊端
父类/父接口不能访问子类特有功能。
(5)多态中的类型转换：
A:向上转型
Fu f = new Zi();
B:向下转型
Zi z = (Zi)f;

举例：孔子装爹。
(6)多态的体现形式：
A:具体类多态
class Fu {}
class Zi extends Fu {}

Fu f = new Zi();
B:抽象类多态
abstract class Fu {}
class Zi extends Fu {}

Fu f =  new Zi();
C:接口多态
interface Inter {}
//接口的实现类命名：接口名+Impl
class InterImpl implements Inter{}

Inter i = new InterImpl();

3：抽象类(掌握)
(1)把多个类中相同的方法声明给抽取出来。定义到一个类中。
   一个方法如果只有方法声明，没有方法体，那么该方法必须定义为抽象方法。
   而一个类中如果有抽象方法，那么，该类必须定义为抽象类。
(2)抽象类的特点：
A:抽象方法和抽象类都必须用abstract表示。
B:一个类继承抽象类的时候；
要么：本身是一个抽象类。
要么：实现抽象类中的所有抽象方法。
C:抽象类不能实例化。可以按照多态的使用方式使用。
D:成员特点：
a:成员变量
可以是变量，也可以是常量。
b:构造方法
有
c:成员方法
可以是抽象，也可以非抽象。
(3)抽象类的好处：
A:抽象类中的非抽象方法提高了代码的复用性。
B:抽象类中的抽象方法强制要求子类必须重写某些方法。
(4)抽象类的案例：
A:猫狗案例
B:老师案例
C:学生案例(自己做的)
D:员工案例
(5)抽象类中的几个小问题：
A:抽象类不能实例化，构造方法有什么用呢?
用于子类访问父类数据的初始化。
B:如果一个类中没有抽象方法，而类却被定义为了抽象类，请问为什么?
不让创建对象。
C:abstract不能和哪些关键字共存：
private: 冲突
final: 冲突
static: 无意义

4：接口(掌握)
(1)如果一个抽象类中的所有成员方法都是抽象的，java就提高了一种更抽象的表达方式：接口。
(2)接口的特点：
A:接口用interface定义。
   类实现接口用implements关键字。
B:一个类要实现接口：
要么：本身是抽象类。
要么：实现接口中的所有抽象方法。
C:接口不能实例化。可以按照多态的使用方式使用。
D:成员特点：
a:成员变量：只能是常量。
            默认修饰符：public static final
b:成员方法：只能是抽象方法。
   默认修饰符：public abstract
(3)类与接口的关系：
A:类与类的关系
继承，单继承。
B:类与接口的关系
实现，单实现，多实现。
继承一个类的同时实现多个接口。
C:接口与接口的关系
继承，单继承，多继承。
(4)案例：
A:猫狗案例用接口实现基本版本。
(5)抽象类和接口的区别:
A:成员区别
抽象类：
a:成员变量
可以是变量，也可以是常量。
b:构造方法
有
c:成员方法
可以是抽象，也可以非抽象。
接口：
a:成员变量：只能是常量。
      默认修饰符：public static final
b:成员方法：只能是抽象方法。
      默认修饰符：public abstract
B:关系区别
a:类与类的关系
继承，单继承。
b:类与接口的关系
实现，单实现，多实现。
继承一个类的同时实现多个接口。
c:接口与接口的关系
继承，单继承，多继承。
C:设计理念不同
抽象类被继承体现的是：is a的关系。抽象类中定义的是继承体系共性功能。
接口被实现体现的是：like a的关系。接口中定义的是继承体系的扩展功能。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2