Java开发知识之Java面相对象

　　　　　　　　　　　　　　Java开发知识之Java面相对象上

一丶什么是面相对象

　　了解什么什么是面相对象.那么首先要了解什么是面相过程. 面相过程的意思就是. 什么事情都亲力亲为. 比如上一讲的排序算法. 我们自己写的. 这个就是面相过程. 而使用面相对象的话.我们直接调用别人写好的sort()方法即可.

面相过程的比喻: 你想吃东西. 买东西. 切菜. 下锅. 做好了. 吃饭.

面相对象: 直接商店买了. 直接吃. 你省去了买东西. 切菜 下锅. 自己做的步骤. 这个就是面相对象.

1.1对象的理解

现实世界中.随处可见的就是对象. 对象就是实体.

比如我们人就是一个对象. 都有各自的脑袋 鼻子 嘴巴. 等等.

1.2 类的理解

　　上面说了.人就是一个对象. 人是属于人类的. 对象是人类的一个实体. 类只是用来描述人该有的一些列信息的.

比如人有头 手 五官 腿 等等. 我们的对象就是基于这些描述来创造出来的.

1.3 面相对象的核心 封装继承.多态.

　　封装.就是指将对象的属性跟行为.封装起来.封装成一个类. 类就是对别人隐藏实现细节. 这个就是封装.什么意思; 意思就是比如人. 人的各种行为.属性. 我把它看做是

一个人类. 我们使用的时候只需要创造一个人类即可. 而不用管 人的器官怎么构成的.

　　继承: 继承就是类跟类之间的关系. 比如父亲跟孩子. 就是有关系的. 孩子可以继承父亲的家产. 就是说孩子如果继承了父亲.那么就能使用父亲的东西.

当然.父亲不可能所有的东西都会被孩子继承.也就是说.父亲的特有的东西孩子不能继承.比如.你们懂得. 所以就有权限一说.

private protected public 分别是私有 保护 跟公共. 父亲私有了,那么你就不能继承这个了. 保护的话就是只有跟自己有关系的才能继承. 比如有儿子 跟女儿. 两个都可以继承. 公共的就是所有人都可以使用.

　　多态:　　多态不难.但是理解起来有点难. 多态就是指.类跟类之间有关系了. 那么父类指向子类. 父类可以使用子类共有的方法.

多态的意思就是指. 同一种操作.有不同的代码展示.

比如 两个类中都有eat方法. B继承A 父类eat输出就是父类吃. 子类输出就是子类吃

A a = new B(); a.eat();

输出结果 子类吃. 为什么是这样的结果.我们明明是父类在前边? 这个就是多态. 父类调用子类行为. 这样的话.如果有很多子类都继承了这个父类.那么我们只需要更换子类.就可以调用子类的特有的方法了.

多态总结就是: 父类指向子类, 运行时调用子类. PS: 子类必须跟父类的方法是一样的.次可以实现多态.

二丶面相对象之Java中类的编写

1.类编写

　　上面我们说了一大堆概念,那么我们要讲一下应用到编程中该怎么编写.

首先上面说了. 类有自己的属性跟行为. 在编程中就叫做 成员变量 与方法. 成元变量就是属性. 行为就是 方法.

语法如下:

权限修饰符 class 类名 {
   权限修饰符 数据类型 成员变量;
   权限修饰符 数据类型 成员变量;
   .....
   权限修饰符 返回值 成员你方法(){
          .....
 }      
  ....
}

public class Anmail {
    public int hand;           属性,成员变量
    public void eat() {        行为,成员方法
        System.out.println("父类吃");
    }
}

上面就定义了一个类. 属性就是 hand(手) 方法就是 eat

我们这个类描述了. 一个动物类. 属性就是有手. 都会吃东西.

2.权限修饰符

　　权限修饰符就是指 private public protected 我们上面也简单说过作用. 其实就是为这个类加权限.如果成员变量是hand. 那么外部不能使用.我们必须提供公共方法去修改才可以. 如果是public. 外面可以直接使用.这样设计就会出现问题. 自己私有的东西.别人如果能随便访问.那么不久出事了.

3.局部变量

　　局部变量就是在方法内部定义的变量. 作用域除了方法就没用了. 也就是方法的{}里面除了{}就不可以使用了. 注意局部变量如果跟成员变量重名.那么你要进行区分.区分就是加上this关键字.

this.hand = hand; hand = 局部变量 this.hand就是成员变量.

　　this关键字代表的就是本类的引用. 可以理解为就是自己这个类. 我指定自己这个类的成员变量.

4.构造方法

　　构造方法是一种特殊的方法.跟成员方法不同.构造方法的作用就是.当对象创建的时候.会首次调用.也就是说自动调用. 如果我们没有写.那么就是默认给我们加了一个空构造.

构造方法跟成员方法的区别就是没有返回值. 普通成员方法没有返回值.是需要加上 void 返回值说明了. 而构造方法不需要. 构造方法的名字必须跟类名一致.

语法:
权限修饰符 类名()    
public class Anmail {
    public Anmail() {}  构造方法,没有返回值
    public int hand;
    public void eat() { 普通成员方法,要加void
        System.out.println("父类吃");
    }
}

构造方法可以进行重载. 意思就是说无参数构造就是没有参数. 如果有参数 就是有参构造.

而且this另一个作用就是可以在构造中调用其他构造方法.注意加红了. 可以在无参构造中使用.也可以在有残构造中使用.而且必须放在首行代码

public class Anmail {
    public Anmail() {
        this("11111111");  //this的另一种使用
        System.out.println("无参数构造方法");
    }
    public Anmail(String s) {
        
        System.out.println("输入的字符串 = "  +s);
        System.out.println("有参数构造方法");
    }
    public int hand;
    public void eat() {
        System.out.println("父类吃");
    }
}

Anmail a = new Anmail();

输出结果

二丶面相对象中的static关键字

1.static关键字以及作用

　　static 表示静态的意思. 可以修饰常量. 变量 以及成员方法.

修饰之后就成了静态常量. 静态变量. 以及静态成员方法.

static关键字修饰可以直接类名调用. 比如我们以前说的Arrays类. 我们可以直接 类名.变量/方法/常量 去使用.

static关键字主要的作用将就是内存共享了.

如上图所示 PI 代表的是3.1415926. 我们需要进行内存共享.

static代码块:

　　static代码块是写在类中的.作用就是用于做初始化的.只会执行一次

static {

　　...

}

static修饰需要注意的问题, 如果修饰成员方法. 那么就是静态成员方法.其内部不可以访问非静态(成员变量.成员常量.成员方法) 因为类不需要创建对象.就可以存在了.而你访问非静态的时候.并没有.因为没有创建对象.

public class Anmail {
    public Anmail() {
        this("11111111");
        System.out.println("无参数构造方法");
    }
    public Anmail(String s) {
        
        System.out.println("输入的字符串 = "  +s);
        System.out.println("有参数构造方法");
    }
    
    public static final int PI = 3; //静态常量
    public static int value1; //静态成员变量 
    public static void run() {
        System.out.println("跑");
    }
    public int hand;
    public void eat() {
        System.out.println("父类吃");
    }
}

定义了静态常量(注意,定义的时候要进行初始化) 静态成员变量. 静态方法.

使用:

　　当我们直接 类名.的时候.会出现静态可以调用的值. 比如PI value 以及run方法.

静态方法不能使用 this 以及 非静态成员变量 方法 常量

我们调用eat方法. 而eat并不是静态成员方法. 所以标红了.代表出错了.eclipse还会提示你修改成静态修饰才可以调用.

在静态方法中还不能使用 静态关键字进行定义局部变量

静态代码块的编写

static {
        System.out.println("静态代码块执行了");
    }

当我们刁颖run方法.他都会先执行静态代码块进行初始化

2.主方法入口点

　　可能有人发现了. 我们的main方法就是static修饰的.

如果是static修饰的那么就需要注意了

1.主方法调用的其他成员方法必须是静态的.

2.主方法没有返回值

3.主方法的参数是一个数组.可以使用数组.length来获取大小.

三丶对象的创建

1.对象的创建

　　上面我们讲了类. 类就是用来描述的.我们真正有用的是对象. 那么对象怎么生成那

类名 变量名 = new 类名(); 后面括号里面可以填写内容 里面可以填写参数.填写的参数就是指定调用类中的有参构造方法.

Anmail A = new Anmail("1111"); new Anmail创建的对象.使用A来代替.
A.eat(); ,直接使用A来访问了.

执行结果

首先静态代码块先执行. 而后我们创建对象的时候使用的有参构造所以有参构造中首先输出我们输入的字符串.然后在输出有参构造方法. 最后我们调用了eat方法.就执行了这个对象的行为.

需要注意的问题: 我们可以创建多个对象. A B C. 但是他们三个的内存是相互独立的.互不影响. B成员变量的修改.不会影响到 A C. 如果有静态修饰的成员变量. 或者常量. 那么他们三个是共享了.

上面我们使用的对象进行访问成员方法. 那么我们也可以访问成员变量. 成员变量如果是 public修饰. 那么可以直接 对象.成员变量 进行访问. 如果是Private 那么我们就要专门提供Set Get 方法来对成员变量进行访问.

也就是说提供了接口. 这样使我们的程序安全性大大增加.

2.对象的引用

　　上面我们说了创建对象如何创建 类名 对象名 = new 类名();

那么引用是什么?

　　引用就是上面所说的对象名 我们可以直接定义对象.然后在new 类名 引用名称; 引用名称 = new....

那么引用有什么意思那?

　　引用可以看成是一个变量. new 类名() 其实是在内存中的堆空间申请了内存. 这块内存的首地址给 对象名(引用)来保存. 那么我们直接就可以通过引用名来访问

对象名.xxxx

　　当然我们也可以不给名字.那么没人保存内存的地址.就成了无名对象.只能使用一次了.

new 类名(). 成员变量 = 10;

new 类名().成员方法();;

3.引用的比较(对象的比较)

　　上面我们简单的说了一下. 对象其实就是保存了内存的地址. 这块地址中有我们的成员变量等各种属性. 那么我们两个对象可以用来比较.

==比较. 如果==比较就是内存地址跟内存地址进行比较了. 因为两个对象的内存地址肯定起始位置不同.进而地址比较就会不同.

而我们程序中.会默认继承一个父类.也就是object类.会继承他的成员方法. equals. 就是进行比较的.我们可以重写这个方法.表示如果调用了这个方法.是比较什么.

我们首先使用String类创建的对象做演示

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String A = new String("123");
        String B = new String("123");
        
        if (A == B) {
            System.out.println(" == 比较 A == B" );
        }
        if(A.equals(B)) {
            System.out.println(" equals 比较 A == B" );
        }

    }

运行结果:

我们使用== 比较的是地址.地址肯定不会相同.所以就不打印. 而是用equals. equals是String内部重写的.他比较的是字符串. 如果字符串相同就是相同了.

4.垃圾回收机制

　　在C++中.创建对象使用 new 销毁对象使用delete 所以有的构造跟析构函数. 但是Java中有垃圾回收机制.所以自然而言就不需要析构函数了.只需要构造函数即可.

垃圾回收机制就是我们不用管内存的释放.他会自己释放这块内存.但是自动是由前提的.必须触发两个条件

1.对象超过其作用域 也就是说我们在一个块语句中生成的对象.超过作用域就会进行销毁

2.对象指向地址为NULL .我们知道对象是内存地址的别称. 如果不指向任何内存地址.那么说明我们申请的哪块地址没人指向了也就没人使用了.Java会把哪块内存给我们释放.

Java中强制进行垃圾回收可以使用System.gc()方法.

四丶面相对象总结

通过本博客可以学习到

　　1.什么是对象

　　　　对象就是基于类生成的一个实体.

　　2.什么是类

　　　　类就是描述行为跟属性的一个模版

　　3.什么是多态

　　　　父类可以指向子类.调用子类跟父类共有的方法

　　4.什么是权限修饰符以及作用

　　　　public private protected 分别是公共 私有 保护. 进行修饰的成员变量则 子类会有不同的继承状态.

　　　　private修饰: 子类继承父类.则不能继承,且外部不可以调用这个成员方法

　　　　public修饰: 子类可以继承父类所有的public修饰的成员(变量/方法) 外部可以直接使用

　　　　protected: 子类继承父类. 只能是继承关系才可以继承.子类继承父类. 其他类不能继承父类.没有关系.

　　5.怎么写一个类模版

　　　　使用关键字 class 即可写一个

权限修饰符 class 类名{
   权限修饰符 类型 成员变量
   权限修饰符 返回值 方法名(参数) {}
}

　　6.类中的成员变量 成员 方法. 有参数无参数构造

　　　　成员变量的定义:

　　　　　　权限修饰符 类型 变量名;

　　　　成员方法的定义

　　　　　　权限修饰符 返回值 方法名(参数){}

　　　　　构造方法:

　　　　　　权限修饰符 类名(参数)// 有参构造

　　　　　　权限修饰符 类名()'; // 无参构造

　　7.this关键字的作用

　　　　1.可以区分成员变另以及局部变量 this.name = name;

　　　　2.可以在构造中调用其他构造 this()调用空构造 this("123"); 调用有参数构造

　　8.static关键字在类中的作用

　静态常量:

　　　　　　权限修饰符 static final 类型 变量名 = 值;

　　　　　　权限修饰符 final static 类型 变量名 = 值; //两者都可以

　　　　静态成员变量

　　　　　　权限修饰符 static 类型 变量名;

　　　　静态成员方法

　　　　　　　权限修饰符 static 返回值 方法名 (参数){}

　　　　静态代码块:

　　　　　　static{....}

　　需要了解的知识点:

　　　　1.静态常量定义的时候需要进行赋值

　　　　2.静态方法不能调用非静态方法.不能使用this关键

　　　　3.静态代码块只会执行一次.且会第一次执行.常用与进行初始化

　　9.对象的引用,比较.以及无名对象

　　1.对象的引用就是一个对象名. 对象名存储着new出来的堆内存.

　　2.无名对象就是不需要对象名去保存首地址了.只需要调用一次.

　　3.对象直接的地址比较可以使用== 如果比较对象中某一成员的值.可以使用 equals.你自己重写equals即可.比较什么你自己写.

String类是比较字符串. 你可以重写.比如比较你类中的某一个值