java面向对象（1）

1.面向对象与面向过程的区别

面向过程（pop）：代码结构以函数为组织单位，适合解决简单问题，首先分析解决步骤，再一一实现（扩展能力差，后期维护难）。

典型语言：c语言。

面向对象（oop）：以类为组织单位，每种事物都有自己的属性与功能，是一种设计者思维，适合解决复杂问题，代码扩展性强，可维护性高。

典型语言：java,c#,c++,Python,Ruby,PHP。

面向过程与面向对象相辅相成。

                                                       面向对象：

面向过程：

 2.类与对象

类：具有相同特征的事物（概念上的定义）。

对象：对象是类的实例，是以类为模板，在内存中创建出一个实际存在的实例

变量：事物属性的描述

方法:事物的行为

构造方法：初始化对象

类的格式

public class compter {
    String name;
    String color;
    float price;
}

访问修饰符：public,无

修饰符：final,abstract

关键字：class来定义一个类

类的共有属性（成员变量）

ublic class person {
    String name;
    int age;
    float hight;

成员变量可以对其初始化，如果不对其初始化，Java使用默认值对其初始化

成员变量的作用范围为整个类体

成员方法

 public void open(){
        System.out.println("电脑打开");
    }
    public void close(){
        System.out.println("电脑关闭");
    }
    public void show(){
        System.out.println("名字："+name+" 颜色："+color+" 价格："+price);
    }

类和对象

对象的创建与使用

使用new关键字，car()----类的构造方法，类中会自动提供。

new car() 使用new关键字创建一个具体对象，对象存在内存中

car bm/bc   声明一个car类型变量=把右边创建的对象赋给左边变量

类是模板，是定义

对象是具体实例

ublic class testcompter {
    public static void main(String[] args) {
        compter lenovo=new compter();
        lenovo.name="联想";
        lenovo.color="银";
        lenovo.price=5000;
        lenovo.open();
        lenovo.close();
        lenovo.show();

方法的重载

方法重载是指一个类中具有相同的名字，但参数不同

（1.数量不同 2.类型不同3.顺序不同）

 public static void main(String[] args) {
        MyMath nu=new MyMath();
        nu.compare2(1,2);
        nu.compare2(1,2,3);
        nu.compare2(1.1,1.2);
        nu.compare2(1.1,1.2,1.3);
    }

方法重载与方法的返回值类型没有任何关系

对象与引用

 public static void main(String[] args) {
        compter lenovo=new compter();
        lenovo.name="联想";
        lenovo.color="银";
        lenovo.price=5000;
        lenovo.open();
        lenovo.close();
        lenovo.show();

        System.out.println("--------------------------------------");

        compter hp=new compter();
        hp.name="惠普";
        hp.color="黑";
        hp.price=6000;
        hp.open();
        hp.close();
        hp.show();
    }
}

1）右边的“new Car()”，是以Car类为模板,在堆空间里创建一个Car类对象。

2）左边的“Car bm”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指 向Car对象的对象引用。

3）”=”操作符使对象引用指向刚创建的那个Car对象。 我们可以把这条语句拆成两部分： Car bm; bm= new Car();

这样写，就比较清楚了，有两个实体：一个是对象引用变量，一个是对象本身。 

值传递

Java中进行方法调用中传递参数时，参数传递有两种：

● 值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应 的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同 的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
 

package oop01;

public class test {
    /*值传递--基本类型作为参数传递
             形参改变后，实参是没有影响，
             是用实参的值，填充了形参，是两个独立的变量。
     */
    public static void main(String[] args) {
        int a=10;
        test test1=new test();
        test1.test(a);
        System.out.println("a="+a);
    }
    public void test(int b){
        b=20;
        System.out.println("b="+b);
    }
}

 引用传递

● 引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参 数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的 操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法 执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。 但是无论是值传递还是引用传递,其本质都是传值,所以也都统称值传递.

 

package oop01;

public class test02 {
    /*引用类型传递--引用数据类型作为参数传递，传递的只是对象的地址，实参和形参
    任何一方改变对方的值，另一方也会改变。
     */
    String name;
    public static void main(String[] args) {
        test02 car=new test02();
        car.name="宝马";
        test02 test02=new test02();
        test02.test(car);
        System.out.println(car.name);
    }
    public void test(test02 car1){
        car1.name="奔驰";
        System.out.println(car1.name);
    }
}