第六章总结

面向对象概述
对象：
世间万物都是对象；

通常划分为两个部分：动态属性和静态属性

动态属性就是对象可执行的动作

静态属性就是不能动的部分，这个部分被称为属性，任何对象都会具备其自身属性

类
类，是同一类事物的统称

类实质上就是封装对象属性和行为的载体

类是对象的设计图

面向对象具有封装性，继承性和多态性的特点

封装
是面向对象编程的核心，将对象的属性和行为封装起来，载体是类。

封装保证了类内部数据结构的完整性，使用类的用户不能轻易的直接操作类的数据结构，只能执行类允许公开的数据，避免了外部操作对内部数据的影响，提高了系统的可维护性。

继承
继承性主要利用特定对象的共有属性，子类可以继承父类所有的属性，子类还可以衍生子类，但最末尾的类依然能继承父类所有的属性

父类和子类存在一种关系，一个类在继承中它即可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类。例如：三角形是图形类的子类也是等边三角形的父类。

多态
其实就是父类对象应用于子类的特征就是多态，多态就是继承父类的所有但又会有不属于父类也不同于其他子类的属性就相当于它的个性。

封装
成员变量和成员方法就是静态属性和动态属性；

大框假设是个文件，那么我们知道了成员变量和成员方法就是静态属性和动态属性，就用代码进行封装

 

 我们定义了成员变量和成员方法，有{ }的就是方法

在定义成员变量时我们会涉及到修饰符，修饰符有四种。

 我们通过这些可以知道我们刚刚定义的修饰符是私有的，不能被其他文件和其他文件中的类使用，那么我们可以使用getter（获取） 和setter（设置）方法，可以让变量除本类外也可以使用

但是当你有100个，200个要设置就会非常麻烦，那么编译器有便捷的方法

这样就会快速的弄好了 

setter 这里我们会用到this.这个意思是这个类，那么在上图就是其他想要修改的值赋值给这个类的值，不然就会是修改的值赋值给修改的值，会冲突。

我们设置了一个类，那要怎么使用呢？

新建一个类，使用我们刚刚定义的类（要有主函数，之前的没有主函数）

定义一个之前文件名字类型的引用叫bird1，在之前文件名字类型里用new创建对象

用new的得到对象，new是调用构造方法 产生一个对象

 我们没有生成构造方法，但编译器却没有报错，因为编译器会默认有一个空的对象

public 返回类型 方法名(传入参数) {

返回参数}

 我们可以在类中设置构造方法，这样就可以在定义的时候直接赋值

但是如果有100多个就很麻烦，编译器有方法可以快速构造完

 这样我们就省了很多事，我们就可以直接使用。

我们可以在对象里定义好数据，这样我们就可以定义的同时赋数据；

代码就会短些

例题6.1

package b;
 
public class s {
    public static int[] exchange(int []arr) {
        int tmp=arr[0];//创建局部变量tmp，保存数组第一个元素的值
        arr[0]=arr[1];//第二个元素值赋值给第一个元素
        arr[1]=tmp;//第二个元素的值赋给tmp
        return arr;
        
    }
    public static void main(String[]args) {
        int arr[]= {17,29};
        System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
        arr=exchange(arr);
        System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
    
    }
}
        

例题6.2

package b;
 
public class s {//类
    private String name;//String类型的成员变量
    public String getName() {//namedeGeteer方法
        return name;
    }
    public void setName(String name ) {//name的Seteer方法
        this.name=name;//将参数赋予类中的成员变量
    }
}
        
结果

例题6.3

package a;
 
public class b {
 
    int egg;//鸡蛋灌饼里蛋的个数
    public b(int egg) {//参数为鸡蛋灌饼里蛋的个数的构造方法
        this.egg=egg;//将参数依据egg的值赋给属性egg
    }
    public     b() {//无参数构造方法默认给饼加一个蛋
        this(1);//调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        b cake1=new b();
        System.out.println("顾客不要求加蛋的数量，饼里会有"+cake1.egg+"蛋");
        b cake2=new b(2);
        System.out.println("顾客要求加2个蛋的数量，饼里会有"+cake2.egg+"蛋");
        }
 
}

 结果

 静态
静态就是static，可以有静态常量、静态变量、静态方法和多个语句静态

静态是这个类的专属，只有这个类可以用，就是这个文件可以用，只要它们在一个文件里就行

例题6.5

package b;
 
public class s {//类
    
    static  int i=0;//共享的属性，人数
    String name;//名称属性
    public s(String name ) {
        this.name=name;//记录名称
        i++;//人数递增
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        s c1=new s("tom");
        System.out.println("我是第"+s.i+++"名顾客，我叫"+c1.name);
        s c2=new s("张三");
        System.out.println("我是第"+s.i+++"名顾客，我叫"+c2.name);
        s c3=new s("狗蛋儿");
        System.out.print("我是第"+s.i+++"名顾客，我叫"+c3.name);
                
    }
 
}

 结果

 (String [] args)有什么用，怎么用

package b;
 
public class s {
    public static void main(String [] args) {//主方法
        for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
            System.out.println(args[i]);//打印结果
        }
    }
}
在代码运行前要先设置参数，右击界面

 点击，然后以下操作

 然后输入，用换行隔开

对象
设置值    描述    设置值    
描述

Test    类名    new     创建对象操作符
test    创建Test类对象    ”a“    构造方法的参数
test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间

例题6.7

package a;
 
public class b {        
    String name;
    int age;
    String sex;
    public b() {
        
    }
    public b(String name,int age,String sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
        
    }
    public static void main(String []args) {
        b p1=new  b("tom",23,"男");
        b p2=new b("lily",19,"女");
        
    }
 
}

 例题6.8

package a;
 
public class b {        
    String name;//名字
    String color;//颜色
    String vioce;//叫声
    
    public b(String name,String color,String vioce) {
        this.name=name;
        this.color=color;
        this.vioce=vioce;
        
    }
    public void call() {//叫
        System.out.println(vioce);
    }
    public static void main(String []args) {
        b d1=new  b("毛毛","白色","汪汪汪");
        System.out.print(d1.name+"的颜色是"+d1.color);//访问对象的属性
        System.out.print("叫起来的声音：");
        d1.call();//访问对象的行为
        b d2=new b("灰灰","灰色","嗷呜~");
        System.out.print(d2.name+"的颜色是"+d2.color);
        System.out.print("叫起来的声音：");
        d2.call();
        
    }
 
}

引用
真正的操作标识符实质上是一个引用，引用的语法

类名 对象的引用变量

b d1 =new b();

b是类名，d1是引用名，new b对象的实体；

对象的销毁
为什么要销毁对象

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收

 垃圾回收器

 在其他语言中，需要用户手动回收废弃的对象，JAVA拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源

 怎么判断对象会被JAVA虚拟机视为垃圾？主要包括两种情况

 对象引用超过其作用范围，这个对象将被视为垃圾

 2.这个对象被赋值为null

 

不足
虽然JAVA的垃圾回收机制已经很完善，但垃圾回收只能回收那些由new操作符创建的对象

 某些对象不是通过new创造并获得存储空间的这些对象是无法被垃圾回收机制所识别

finalize（）
 那么JAVA提供了一个finalize方法

这个方法是object类方法，他被声明为protected，用户可以在自己的类中定义这个方法，定义了这个方法后，垃圾回收时会首先调用该方法

system.gc()
由于垃圾回收不受人为控制，具体的执行时间也不能明确的确定，所以finalize()方法也就无法执行，因此JAVA又提供了system.gc()方法来强制启动垃圾回收器，会主动告知垃圾回收器来清理垃圾

课后作业

 

package b;
 
public class rw {
    //变量
    String xing;
    String ming;
    String se;
    String jiao;
    //get   set
    public String getXing() {
        return xing;
    }
    public void setXing(String xing) {
        this.xing = xing;
    }
    public String getMing() {
        return ming;
    }
    public void setMing(String ming) {
        this.ming = ming;
    }
    public String getSe() {
        return se;
    }
    public void setSe(String se) {
        this.se = se;
    }
    public String getJiao() {
        return jiao;
    }
    public void setJiao(String jiao) {
        this.jiao = jiao;
    }
    
    //方法
    public String introduce() {
        return xing+"狗"+ming+"是"+se+"的";
    }
    public String bark() {
        return xing+"狗"+ming+"正在"+jiao+"叫";
        
    }
    //构造方法
    public rw()
    {
        
    }
    public rw(String xing, String ming, String se) {
        super();
        this.xing = xing;
        this.ming = ming;
        this.se = se;
    }
    public rw(String xing, String ming, String se, String jiao) {
        super();
        this.xing = xing;
        this.ming = ming;
        this.se = se;
        this.jiao = jiao;
    }
    
    
}
 

package b;
 
public class rwte {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //使用有三个参数的构造方法新建对象
        rw rw1=new rw("公","小花","黑色");
        //调用并打印introduce
        String introduce=rw1.introduce();
        System.out.println(introduce);
        //使用有四个参数的构造方法新建对象
        rw rw2=new rw("母","小黑","花色","汪汪汪");
        //调用并打印 bark
        String bark=rw2.bark();
        System.out.println(bark);
        }
 
}