面向对象编程（一）

一、理解面向对象

结构化程序设计

1、程序=算法+数据结构

2、算法第一，数据结构第二

 

二、面向对象程序设计OOP

1、程序=对象+对象+…

2、据第一，算法第二

3、关键：让每个对象负责执行一组相关任务

 

三、面向对象编程的特性

1、万物皆对象

2、程序是一组对象彼此之间在发送消息

3、每个对象都有自己的内存占用，可以组装成更大的对象

4、每个对象都有类型，特定对象的所有类型都可以接收相同消息

 

四、类和对象的概念、区别和联系

概念：

类①类是创建对象的模板和蓝图②类是一组类似对象的共同抽象定义

对象①对象是类的实例化结果②对象是实实在在的存在，代表现实世界的某一事物

对象的两个关键特性①行为:对象能干什么②状态:对象的属性，行为的结果

区别：①类是静态定义②对象是动态实例③程序代码操作的是对象而非类④建模得到的事类而非对象

联系：①类是对象的定义②对象的产生离不开类的建模③类存在的目的是实例化得到对象

 

五、类的建模：抽象和封装的过程

定义一个类的步骤：①定义类名②编写字段代表属性③编写类的方法代表行为

类的建模是一个抽象和封装的过程

抽象：去掉不关注的、次要信息而保留重要的信息

封装：信息打包，简单来说：将抽象出来的属性和行为包装在一个类中。

 

案例：学生类建模

案例介绍：编写一个学生类，描述具有一定行为和属性的学生对象

案例设计：①建模一个学生类②定义一系列字段来描述学生的属性③定义一系列方法来描述学生的行为

public class Student
{
    public String number;
    public String name;
    public int age;
    public String major;
    
    //上课方法
    public void attendClass(){
        
    }
    
    public void exan(){
        
    }
}

 

六、对象的创建和使用

创建并使用对象：使用new关键字创建对象

示例：

public class Example()

{

         int field1;

         double field2;

         public class void main(String []args)

         {

                   Example e=new Example();

　　  }

}

 

使用成员访问符“.”操作对象

给对象属性赋值：对象名.属性

对对象发送消息即调用方法：对象名.方法()

示例：

Example e=new Example();

e.field1=100;

e.field2=200.0;

System.out.println(e.toString());

代码举例

public class Dog
{
    public String brand;//品种
    public int age;//年龄
    //方法
    public String toString(){
        return "这是一条"+age+"岁的"+brand;
    }
    
    public static void main(String []args){
        Dog dog=new Dog();//构造了一个Dog类的对象
        dog.brand="中华田园犬";
        dog.age=3;
        System.out.println(dog.toString());    
    }
}

 

七、方法的定义和调用

类的方法代表的是实例的某种行为（或功能）

方法定义：方法类型，方法签名(方法名+参数列表)，方法体

定义类的方法

访问修饰符 类型 方法名(参数列表){

         //方法体

}

可以把方法当做是一个模块，是个“黑匣子”，完成某个特定的功能，并返回处理结果

方法分类：①返回值为（空）void的方法②带具体返回类型的方法③不带参数的方法④带参数的方法

方法返回值：如果方法有返回值，方法中必须使用关键字return返回该值，返回值类型为该方法所定义的返回值类型

☆方法内可以调用其他方法

调用带参数的方法采用的是值传递方式：①如果参数是基本数据类型，参数传递是将参数的数值传递给方法②如果参数是对象或数组，参数传递是将对象或数组的引用值传递给方法③递参数时都有一个值拷贝的过程

void method1(){

         …

         …

         method2(1,2.0);//方法调用，传入实参（1,2.0）

}

method2(int i,double d){

　　   //i和d表示形参，调用了之后i=1;d=2.0;传参的时候数据类型必须一致

         …

         …

}

public class MethodDemo
{
    public void method1(){
        System.out.println("返回类型为空且无参数的方法");
    }
    
    public String method2(){
        return "带有具体返回类型且无参数的方法";
    }
    
    public void method3(String name){
        System.out.println("返回类型为空且带有参数的方法，参数的值为"+name);
    }
    
    public String method4(String name,int age){
        return "带有具体返回类型且带有参数的方法，参数的值为"+name+"，"+age;
    }
    
    //传递基本数据类型
    public void operatorData(int age){
        //这里的age是定义在外面的age拷贝值，并不是外面的age+1;
        age++;
        System.out.println("方法中的age："+age);
    }
    
    //传递引用数据类型的方法
    public void operatorArray(int[] array){
        array[2]=100;
        System.out.println("方法中的array[2]："+array[2]);
    }
    
    public static void main(String []args){
        MethodDemo demo=new MethodDemo();
        demo.method1();
        String msg=demo.method2();
        System.out.println(msg);
        demo.method3("张三");
        System.out.println(demo.method4("张三",20));
        
        int age=20;
        demo.operatorData(age);
        System.out.println("方法外的age："+age);
        
        int[] array={1,2,3,4};
        demo.operatorArray(array);
        System.out.println("方法外的array[2]："+array[2]);
    } 
}

上述代码中

传递基本数据类型时方法内与方法外的值分别为11与10

传递引用数据类型时方法内与方法外的值都为100

区别分析：

基本数据类型在内存中存放在栈内存中，当使用int时开辟一个栈帧(age)，调用方法后又产生了一个栈帧(age)，方法内操作的是第二个，当调用完方法之后第二个age出栈了，但第二个age改变了值并打印，未影响到第一个age，主方法中继续打印输出age（此时是第一个age）；引用数据类型使用array时开辟一个栈帧(array)，指向堆中的内存空间，调用方法后又产生了一个栈帧(array)，由第一个array传递过来（地址），也指向了堆中的内存空间，方法内操作的是第二个，当调用完方法之后第二个array出栈了，指向的堆中的内存空间中的数组array[2]中的值改变了，所以2个array[2]输出的是相同的值。

主要区别就是基本数据类型存放在栈中，而引用数据类型只是将地址存放在栈中，真正的值存放在堆中。例如int[] a=new int[5]; 其中a存放在栈中，a只是一个引用，栈中放的数组的地址，真正的数组是放在堆中的。

 

八、变量的作用域

public class Example(){

         public 类型 变量1;

         public 类型 变量2;

         public 类型 方法1(){

                   类型 变量3;

}

public 类型 方法2(){

                   类型 变量4;

}

}

 

上面的例子中变量3和变量4为局部变量，变量3只能在方法1中使用，变量4 只能在方法2中使用。变量1和变量2是成员变量(属性)，在方法1与方法2中都能使用。

 

九、String对象的声明和操作

①常用创建方式

String s=”阿里巴巴”;

String s1=”abcd”;

String s2=”abcd”;

如图：s1与s2指向同一个字符串池

②不常用创建方式

String s=new String(“阿里巴巴”);

String s1= new String(“abcd”);

String s2= new String(“abcd”);

s1==s2 → false
如图：s1与s2指向不同字符串池

String对象是不可变的;

①类中每一个看来会修改String值的方法，其实都是创建了新的String对象（包含修改后的字符串内容）;

②String的只读特性带来效率优化可能;

③字符串字面值存储于字符串池中，String对象优先指向该字符串池，避免反复生成重复的字符串实例;

④系统对String的非修改处理效率很高，远远超过另外两个字符串类StringBuilder和StringBuffer;

 

String对象的常用方法

①   length()--返回此字符串的长度;

②   charAt(int index)--返回指定索引处的char值;

③   concat(String str)—将指定字符串连接道此字符串的结尾;

④   contains(CharSequence s)—是否包含指定的字符串序列;

⑤   equals(Object anObject)—将此字符串与指定的对象比较;

⑥   compareTo(String anotherString)—按字典顺序比较两个字符串;

⑦   indexOf(int ch)—返回指定字符串在此字符串中第一次出现处的索引;

⑧   split(String regex)—根据匹配给定的正则表达式来拆分此字符串;

⑨   substring(int beginIndex)—截取字符串;

⑩   toLower/toUpperCase ()—将指定字符串进行大小写转换;

⑪   ......

在JDK API中搜索String可以看到用法

public class StringDemo{
    public static void main(String []args){
        String content="Hello,My Friend,You are my best friend";
        //返回指定索引处的字符
        System.out.println(content.charAt(2));//输出l
        
        //按字典顺序比较两个字符串
        System.out.println(content.compareTo("hello"));//-32
        
        //将指定字符串连接到此字符串的结尾
        //content.concat("I lied");
        //System.out.println(content);//Hello,My Friend,You are my best friend
        //content=content.concat("I lied");
        //System.out.println(content);//Hello,My Friend,You are my best friendI lied
        
        //测试此字符串是否以指定的后缀结束
        System.out.println(content.endsWith("friend"));//true
        
        //测试此字符串是否以指定的前缀开始
        System.out.println(content.startsWith("Hello"));//true
        
        //当且仅当此字符串包含指定的 char 值序列时，返回 true
        System.out.println(content.contains("My"));//true
        
        //比较
        String s1="abc";
        String s2="abc";
        System.out.println(s1==s2);//true
        System.out.println(s1.equals(s2));//true
        
        String s3=new String("abc");
        String s4=new String("abc");
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//true
        
        //返回指定子字符串在此字符串中第一次出现处的索引
        System.out.println(content.indexOf("o"));//4
        
        //返回指定子字符串在此字符串中最后一次出现处的索引
        System.out.println(content.lastIndexOf("o"));//17
        //返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
        System.out.println(content.indexOf("o",5));//17        
        
        //返回此字符串的长度
        System.out.println(content.length());//38
        
        //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
        System.out.println(content.replace('e','a'));//Hallo,My Friand,You ara my bast friand
        
        //根据给定正则表达式的匹配拆分此字符串,返回数组
        String[] arr=content.split(" ");
        System.out.println(arr.length);//6
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
        //从下标5处开始截取
        System.out.println(content.substring(5));//,My Friend,You are my best friend
        //从下标5处开始截取(9-5)个字符
        System.out.println(content.substring(5,9));//,My   此处y后面有一个空格
        
        //输出全小写
        System.out.println(content.toLowerCase());
        //输出全大写
        System.out.println(content.toUpperCase());        
    }
}

面向对象的优点

①便于程序模拟现实世界中的实体：用“类”封装建模实体对象的状态和行为;

②隐藏细节：对象的行为和状态被封装在类中，外界通过公开的接口----调用类的方法开获得状态信息，不需关注内部细节如何实现;

③可重用：可以通过类模板，创建多个对象实例，重用类的定义代码;

 

Java对象的内存管理机制

①   使用new 创建对象，在堆内存分配对象空间、初始化;

②   在方法栈中定义局部变量，持有对堆内存中对象的引用;

③   方法执行完返回，栈内存自动释放，局部变量销毁;

④   如果堆内存中对象没有变量引用它，成为垃圾，由垃圾回收器回收，释放所占堆内存;

 

Java垃圾回收器

①   Java运行时系统有一个垃圾回收线程负责清除不再使用的对象，俗称垃圾回收器;

②   垃圾回收器定期扫描内存，对于被使用的对象加上标记，按可能的路径扫描结束后清除未加标记的对象

③   被回收的对象：1、不再被任何变量引用的对象;2、引用变量自动放弃;3、人为将引用变量置为null;