======================================================================
第三天: 面向对象 [精]
======================================================================
（1）继承: 为什么? 继承不是为了代码重用.
面相对象: 对象是: 客观存在的事物: 有什么: [属性] 能做什么: [方法].
对象和对象组合.彼此调用互相的方法来构造一个大系统.
我是这样理解的: 也就是组件化模式.组件也就是一个对象.如果要完成一件任务,要找到一个解决这个问题的方法,也就是public void print(){
System.out.pirntln();
}适合这个问题的方法(对象)
例子: 任务: 从北京--天津
第一步: 找一个交通工具,[走路,骑车,汽车,火车,飞机] -----就是找到适合这个问题组件,这个组件不一定是自己写的,但如果没有这个组件,我们可以自己写.
这样有些代码可以用别人写的代码,来解决自己的问题.这样可以在别人的代码基础上来提高开发效率.也就是站在别人的肩膀上[继续开发.].就像一辆汽车[组件]不是你制造的但是你能够用他来带你去其他地方[帮你解决问题].
面相对象的特点: 允许我们用解决现实问题的方法,来解决计算机问题.
面相对象的好处: 让一个对象简单,各司其职/个尽所能.简单对象拼装成大系统. 为什么要让一个对象执行一个尽量简单的工作.因为专才能精.
对象和对象之间要存在弱藕合状态. //接口一样.标准 :防止垄断.先找有没有对象能解决我这个问题.如果没有则自己开发一个组件.自己的组件和别人的组件结合起来，来解决实际的问题。
可重用性: 这个代码能够让其他的程序用到。
可扩展性: 继承，子类继承父类的所有属性和方法，然后根据实际情况来扩展自己的方法和属性，以适应实际的环境。
面向对象: 该重用的重用,该自己写的自己写,然后在拼装成一个系统.
面向对象: 先有数据结构,后有算法.
面向过程: 先有算法,后有数据结构.
类,模板,类是对象的抽象.
在编程中,类是对象的模板.
=====================================================================
(2) 实例变量:
在类体里定义的变量[属性]一个属性其实是一个实例变量在[任何方法外].
实例变量有默认值:
在方法里定义的是局部变量,作用范围[定义这个变量的代码块]
例子:
class ClassA {
int a = 10; // 局部变量才要先赋值,后使用.而实例变量可以不给默认值.
public void print() {
int a = 10; // 两个局部变量才会出现命名冲突.一个实例变量和一个局部变量不会命名冲突.
System.out.println(a); // 然后局部优先.
}
}
======================================================================
(3) OverLoad(重载) :
编译时多态. 方法名相同参数表不同.返回值没有限制;编译时就决定,了调用了哪个方法.
有什么用: 调用者负责给参数,编译器负责调用哪个函数,//这样适合各司其职的特性.
//屏蔽由于参数的不同而造成的差异.
public class Test{
public static void main(String args){
ClassA a=new ClassA(); // 向上就近匹配.
}
}
public class ClassA{
public void print(){
System.out.pirntln();
}
public void print(short,short){
System.out.pirntln();
}
public void print(byte,byte){ //
System.out.pirntln();
}
public void print(short,byte){ // 此时编译不通过.因为编译器分不清楚调用哪个函数.
System.out.pirntln();
}
public void print(byte,short){
System.out.pirntln();
}
}
======================================================================
(3) 构造方法
1.初始化属性.
2.打开网络联接.对象的构造过程
1. 分配空间.int a=0; 堆空间(存放对象,连续的存储区域,属性) //(卵着床).
2. 初始化属性, int a=10; //(10月怀胎)
3. 调用一个构造方法. 只在构造的时候被调用一次.(婴儿剪脐带) //最好主动加上构造方法.
3. 构造方法可以重载.
(4) 对象变量 (引用)
ClassA a=new ClassA(); //a是一个对象变量(引用);
简单变量存储一个变量
对象变量存储一个对象的指针因此可以这样写: ClassA c=null; //c里面装的地址.(叫做引用)
c=new ClassA();
(5) 对象和引用的关系: (出自--Java In Thinking)
如果我们说: 一个对象是一个电视机,引用是一个遥控器. 我们通过遥控器访问电视机. 例子: ClassA c=null;
c=new ClassA(); //通过new 来构造一个对象.
ClassA c2=c; //c2 和 c 指向同一个对象.
//引用有引用的类型,可以两个遥控器可以同时访问一个电视机. 对象有对象的类型.
//java中的属性默认是public 的.
(6) 传值/传引用.
int a=0;
ClassA s=new Class();
s.method(a); //此时这里的a 没有变，传的是值。
//[基本类型,传值，对象类型传引用]
student b=new student();//引用会改变他的值。
s.method(b.age); //此时age会变化. 因为b是一个地址.传的是引用. //[对象类型,传引用]
class ClassA{
void method(a){
a++;
}
}
class student{
int age=10;
}
(7) this 关键字.
作用：
1. this. //是当前的对象的引用
2. 用this. 来区分实例变量和局部变量.
例如:
int a=0;
void pirnt(){
int a=0;
System.out.println(this.a); //用来指向实例变量a,而不是此时的局部变量a.[屏蔽局部优先原则.]
}
3.用在构造方法里.
例子:
public ClassA{
ClassA(){
System.out.println("ClassA()");
}
}
public ClassA(int a){
ClassA(); // 不能这样调用.
this(); // 调用本类中其他的构造方法. 此时是无参的 //this() 必需是本类的第一个语句.放在后边不行.
}三
类---->属性
方法 -->声明/实现->重载.
构造方法:
构造过程: new
引用: 传值/传引用;
this. 2中的方法.1,在构造函数外面用，2，在构造函数中用，用来初始化属性，区分形参和属性。
(8) 修饰符:
同一类同一包子类外部程序
| Private | V | X | X | X |
| Protected | V | V | V | X |
| Default | V | V | X | X |
| Public | V | V | V | V |
======================================================================
（ 1 ）继承 : 为什么 ? 继承不是为了代码重用 .
面相对象 : 对象是 : 客观存在的事物 : 有什么 : [ 属性 ] 能做什么 : [ 方法 ].
对象和对象组合 . 彼此调用互相的方法来构造一个大系统 .
我是这样理解的 : 也就是组件化模式 . 组件也就是一个对象 . 如果要完成一件任务 , 要找到一个解决这个问题的方法 , 也就是 public void print(){
System.out.pirntln();
} 适合这个问题的方法 ( 对象 )
例子 : 任务 : 从北京 -- 天津
第一步 : 找一个交通工具 ,[ 走路 , 骑车 , 汽车 , 火车 , 飞机 ] ----- 就是找到适合这个问题组件 , 这个组件不一定是自己写的 , 但如果没有这个组件 , 我们可以自己写 .
这样有些代码可以用别人写的代码 , 来解决自己的问题 . 这样可以在别人的代码基础上来提高开发效率 . 也就是站在别人的肩膀上 [ 继续开发 .]. 就像一辆汽车 [ 组件 ] 不是你制造的但是你能够用他来带你去其他地方 [ 帮你解决问题 ].
面相对象的特点 : 允许我们用解决现实问题的方法 , 来解决计算机问题 .
面相对象的好处 : 让一个对象简单 , 各司其职 / 个尽所能 . 简单对象拼装成大系统 . 为什么要让一个对象执行一个尽量简单的工作 . 因为专才能精 .
对象和对象之间要存在弱藕合状态 . // 接口一样 . 标准 : 防止垄断 . 先找有没有对象能解决我这个问题 . 如果没有则自己开发一个组件 . 自己的组件和别人的组件结合起来，来解决实际的问题。
可重用性 : 这个代码能够让其他的程序用到。
可扩展性 : 继承，子类继承父类的所有属性和方法，然后根据实际情况来扩展自己的方法和属性，以适应实际的环境。
面向对象 : 该重用的重用 , 该自己写的自己写 , 然后在拼装成一个系统 .
面向对象 : 先有数据结构 , 后有算法 .
面向过程 : 先有算法 , 后有数据结构 .
类 , 模板 , 类是对象的抽象 .
在编程中 , 类是对象的模板 .
=====================================================================
(2) 实例变量 :
在类体里定义的变量 [ 属性 ] 一个属性其实是一个实例变量在 [ 任何方法外 ].
实例变量有默认值 :
在方法里定义的是局部变量 , 作用范围 [ 定义这个变量的代码块 ]
例子 :
class ClassA {
======================================================================
(3) OverLoad( 重载) :
有什么用: 调用者负责给参数,编译器负责调用哪个函数,//这样适合各司其职的特性.
//屏蔽由于参数的不同而造成的差异.
public class Test{
(3) 构造方法
1.初始化属性.
2.打开网络联接.对象的构造过程
1. 分配空间.int a=0; 堆空间(存放对象,连续的存储区域,属性) //(卵着床).
2. 初始化属性, int a=10; //(10月怀胎)
3. 调用一个构造方法. 只在构造的时候被调用一次.(婴儿剪脐带) //最好主动加上构造方法.
3. 构造方法可以重载.
(4) 对象变量 ( 引用)ClassA a=new ClassA(); //a是一个对象变量(引用);
简单变量存储一个变量
对象变量存储一个对象的指针因此可以这样写: ClassA c=null; //c里面装的地址.(叫做引用)
c=new ClassA();
(5) 对象和引用的关系: (出自--Java In Thinking)如果我们说: 一个对象是一个电视机,引用是一个遥控器. 我们通过遥控器访问电视机. 例子: ClassA c=null;
c=new ClassA(); //通过new 来构造一个对象.
ClassA c2=c; //c2 和 c 指向同一个对象.
//引用有引用的类型,可以两个遥控器可以同时访问一个电视机. 对象有对象的类型.
//java中的属性默认是public 的.
(6) 传值/传引用.
ClassA s=new Class();
s.method(a); // 此时这里的 a 没有变，传的是值。
//[基本类型,传值，对象类型传引用]
student b=new student();// 引用会改变他的值。
s.method(b.age); //此时age会变化. 因为b是一个地址.传的是引用. //[对象类型,传引用]
class ClassA{
void method(a){
a++;
}
}
class student{
int age=10;
}
(7) this 关键字.作用：
2. 用this. 来区分实例变量和局部变量.
例如:
void pirnt(){
int a=0;
System.out.println(this.a); //用来指向实例变量a,而不是此时的局部变量a.[屏蔽局部优先原则.]
}
3.用在构造方法里.
例子:
public ClassA{
方法 -->声明/实现->重载.
构造方法:
构造过程: new
引用: 传值/传引用;
this. 2中的方法.1,在构造函数外面用，2，在构造函数中用，用来初始化属性，区分形参和属性。
(8) 修饰符:
同一类同一包子类外部程序
|
Private
|
V
|
X
|
X
|
X
|
|
Protected
|
V
|
V
|
V
|
X
|
|
Default
|
V
|
V
|
X
|
X
|
|
Public
|
V
|
V
|
V
|
V
|
5090
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
