面向对象和方法重载

1、B/S  Broswer/Server

C/S Client/Serve

面向机器

   01010101

汇编语言：介入了一些符号，标记来做程序

面向过程

    C高级程序语言 for（int i； i < 5; i++）{}

    解决思考问题的角度

一步一步的解析，把一个大问题分解成好多小问题，然后多个小问题串联起来就解决了大问题，函数之间的调用；

面向对象

        思想：解决问题的时候，不陷入细节，他是站在对象整体的角度去考虑问题

  C++

java

对象：现实生活中的事物，万物皆对象

类：对现实生活中的一类事物的抽象，抽象的存在，类好比图纸，

类就是由现实生活中的某一个具体的对象抽象而来，是一个模板，代表着具有相同特征和行为的一类对象；

面向过程：

  优点：适合对效率要求高，比较灵巧，底层，比如驱动程序的开发，跟硬件关系密切；

   缺点：不适合做大的项目，会产生成千上万的函数调用，他们之间的耦合度过长，密切，出了问题很难找，只要一个函数出了问题，可能整个功能都受到影响

面向对象

    优点：比较容易维护，后期的扩展，二次开发，功能上容易扩展，适合做大型项目

    缺点：效率相对较低，游戏，驱动。。。。

参数（消息）的传递

    涉及到对象和对象之间的传递，通过对象的行为来做传递

对象内部消息之间的传递

class Student{

public void say（String teacher）{//形式参数：形参

drink（“water”）；

System。out.println(“say........”);

}

}

        class Teacher

{

public void answer(String name)

{

  Student.say(name); //实参

}

}

面向对象的三大特征

1.封装

封装是隐藏甚至是欺骗，封装隐藏了对象内部的具体实现，只对外界开放了接口。封装性代表了现实世界生活中具体的对象，他们的特征所具有的隐蔽性，对象的属性一般是被隐藏起来的；一个对象的属性一般是被封装隐藏起来的，对象的行为方法一般是被开放的public。

class Student{

private String name；}

2.继承

子承父业，为了简化代码的书写；

为了重用，复用父类的代码；

extends

class A extends B{}

继承：：父子关系 （is-a）  dog is a animal

组合：has -a apart of

class Computer{

KeyBoard  kb；

}

class KeyBoard{}

class Person{}

class Leg{}

      组合：键盘与电脑

      聚合：Leg与身体的关系；

3.多态

同一个引用可以调用不同对象类型的方法；

子类与父类之间的

父类的引用可以调用子类的方法；

程序在运行前将不知道要调用哪个方法；

方法重载：名字相同参数的列表（形式参数）不同的两个（或多个）方法称为重载方法，

重载方法的语言环境：

参数列表的不同体现在以下两点

{

***参数列表的个数不相同

***参数列表所对应的参数类型不同

}

构造器：

//面向对象

//对象的使用，方法的调用，成员变量，局部变量，变量的默认值

参数的传递

值传递 基本类型

引用传递  引用数据类型

对象的使用  

     先声明 类名 对象名；

        初始化  new 类名（）；

       创建对象的过程叫实例化；

       内存中的变化

      声明时在栈内存中分配了变量名的空间，此时变量名是一个对象（引用）类型的  

      初始化时在堆中分配了对象的内存空间，还将对象所在的地址

     Person  p ； //在栈内存中创建了对象的引用，此时这个引用值是null；

     p  = new Person（）； //在堆内存中创建了对象，并将该对象的引用

//C语言中的指针；

int *p ；

int a = 10；

p = &a；

参数的传递

    形参 ：一般在写一个方法的时候，在方法中定义一个局部变量

        public void f（int x，int y）{}

           实参：调用该方法的时候，实际传递过去的参数

     可变参数：f(int ...a)   f（1） f（1，2，3，4）  f（3，4）；

public static void main（String ... args）       

参数的值传递

两种方式都是值传递

引用类型：f（A x）

      A  a = new A(); int i = 10;

      f(a);

a, x ----------------> A

x----------------> A     i + 10;

a-------------------->A

栈产生两个引用变量值相等

栈          堆内存

a              A

x

基本类型：

int a = 100；

f(int x)

{

x = x + 100;

}

f(a);   x = a;      //x无论发生什么变化，与a无关a复制了一份给了x

a = 100;

方法的重载

为了重复利用

参数类型不一样

参数的个数不一样

参数的顺序不一样

Overload 发生在一个类中，与父类没有关系

class A

{

public void query(int id)

query(int id,String name);

}             

构造器

      每一个类都有一个构造器，用来对对象进行初始化。

      是对象被创建出来自动调用的第一个方法；没有返回值；

     构造器也叫构造方法，没有返回值，但也不是void

     默认是无参的构造方法

     方法名与类名相同

构造器的重载

class A{

public A（）

{}

public A（int i， int j）

{}

public A（String x）

{}

}

A a = new A(); //调用构造方法了吗？无参

A a2 = new A(2,3);

成员变量局部变量和方法；

成员变量：类范围内定义，有默认值，在堆内存中，作用于整个类

局部变量：没有默认值，在栈内存中，作用与局部

在同一个类创建多个对象时

          局部变量会隐藏成员变量

         成员变量各对象独有

         方法个对象共享；

变量的默认值：

                   基本数据类型的默认值

                 引用类型：NULL；

this

正在执行本方法的当前对象；

class A{

private int a；

public void f（int a）

{

this.a= a；

}

}

A a = new A();

a.f(23, A this) //this = a;