------- android培训、java培训、期待与您交流！ ----------
坚持下去,每天进步一点点 <学习就像烧开水,停顿的一小会,需要更多的时间来弥补>
一. 面向对象概述
1. 什么是面向对象
(1) 面向对象是基于面向过程的, 面向对象是从面向过程发展来的.
(2) 面向对象和面向过程都是一种思想.
(3) 面向过程强调的是动作,面向对象将功能封装进了对象,强调具备了功能的对象.
(4) 面向对象的三个特征: 封装,继承,多态.
举例: 把大象放到冰箱分几步?
面向过程: 1.打开冰箱门 2.将大象放过去 3.关上冰箱门
面向过程的思想注重的是动作.
面向对象:
注重的实体.
首先要做的是找到实体:
1.冰箱.
2.大象.
动作:打开 放入 关上
动作具体赋予哪一个实体?
示例
人开车
人扇扇子
分析：名词分析法 在完成的具体操作中，一般把名词提出变成实体
把动词提取出来变成动作.
人操作ATM
存钱 取钱 查看 退出
实体:人 ATM
ATM动作:存 取 查 退出
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系。
当发现动作赋予给某几个实体都可以，那么我们去分析，做这个动作
在哪一个实体中会更简单，就将其声明在哪个实体中。
2. 面向对象的好处
是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
二. 面向对象中的类对象方法属性
1.类
类:将具有相同的特征与行为的一类事物的抽象.
对象:是类的一个具体化(实例化)
类与对象之间的关系:类是对象的抽象，而对象是类的具体化(实例化)********
我们在归纳或总结一类事物时，一般是从两方面入手1.外在的特征外貌 2.动作 行为.
类中包含两部分:1. 成员属性 2. 成员方法(函数)
2.对象的创建&如何使用属性&方法
class 类名{
属性
方法
}
1.创建对象
创建变量 类型 变量名字 = 值;
int i=10;
int i;声明
i=10;初始化
创建对象
类名 引用=new 类名();
类名 引用;
引用=new 类名();
2. 使用对象
通过操作符.操作
我们创建某个类的对象后，要使用它，使用它做的事情无非是调用这个对象所
对应的类中存在的属性与方法.
使用属性
引用.属性
使用方法
引用.方法()
当创建一个类的对象时，对象是在堆内存中的。
对象中只包含成员属性，而不包含方法。
方法只要在调用时才加载到内存中，所有的对象使用的
是同一个方法。
在一个类中声明了成员方法，在方法内使用了成员属性，
那么这些属性是属于调用这个方法的对象的属性。
class 人{
//属性
int 年龄;
String 姓名;
//方法
void 吃(){
}
void 睡(){
}
}
成员属性：它可以是java中的任意一种数据类型.
3.成员变量与局部变量区别
成员变量:声明在类中的变量, 局部变量:声明在方法内的.
区别:
1.初始值
成员变量有默认值。
局部变量在使用前必须初始化。
2.内存空间
成员变量它保存在堆内存中--它是随着对象的创建而创建的。
局部变量在栈空间。
3.生命周期
成员变量是保存在对象中它随着对象创建而创建，随着对象销毁而销毁。
局部变量是当使用完后会自动清理
4.作用域
成员变量在整个类内都有效
局部变量只在其声明的方法或代码块中使用。
举例:
class Demo5
{
int id;//成员属性
public static void main(String[] args)
{
Demo5 d=new Demo5();
System.out.println(d.id);//有默认值
}
void print(){
int a=10;//局部变量
System.out.println(a);
for(int i=0;i<10;i++){}
}
}
4.匿名对象
匿名对象只能使用一次。
通过匿名对象去调用其属性没有意义,看见能看懂就可以了。
匿名对象我们什么时候使用
1.通过匿名对象调用方法。只调用一次就可以完成操作。
在后面学到的图形界面中会使用。
2.将匿名对象做为参数传递.
class Demo6
{
public static void main(String[] args)
{
/*
Human h=new Human();
h.name="张三"; //引用.属性
h.show(); //引用.方法
*/
/*
new Human().name="张三";
new Human().show();
*/
//匿名对象做为参数传递
//Point p=new Point();
PointTools tools=newPointTools();
tools.showPoint(new Point());
}
}
class Point
{
int x=10;
int y=20;
}
classPointTools
{
void showPoint(Point p){
System.out.println("X:"+p.x+" Y:"+p.y);
}
}
class Human
{
String name;
void show(){
System.out.println(name);
}
}
三.类与类之间的关系.
依赖:类A的方法操纵了类B的对象
聚合:类A的对象中包含类B的对象(类A的一个属性是类B的对象)
继承:后期日志着重分析.
举例:
class Demo7
{
public static void main(String[] args)
{
}
}
class A
{
B b=new B(); //聚合关系
void show(){
B b=new B(); //A与B之间存在依赖关系
}
}
class B
{
}
四.方法参数是基本类型与引用类型的区别
小练习: 看看你能一眼看出答案么．
package com.itheima.test
public class DataDemo {
public static void main(String[] args) {
Point p = newPoint();
p.x = 10;
p.y = 20;
int x = 10;
int y = 20;
PointTools pointTools = new PointTools();
System.out.println("这里传递的是基本数据类型.....基本");
pointTools.change(x,y);
System.out.println(x +" - "+ y);
System.out.println(p.x +"-" + p.y);
System.out.println("这里传递的是引用数据类型.-------引用");
pointTools.change(p);
System.out.println(x +" - "+ y);
System.out.println(p.x +"-" + p.y);
System.out.println("通过他们的输出结果,你发现了什么?");
}
}
class Point {
int x;
int y;
}
class PointTools {
void change(Point p) {
p.x = 100;
p.y = 200;
}
void change(int x ,int y){
x = 150;
y = 250;
}
}
五.封装
面向对象语言三个基本特征:封装 继承 多态
封装
封装最基本的目的是为了提高程序的安全性。
类是一种封装，它封装了属性与方法
对象封装了成员属性
方法也是一种封装，它封装了功能.
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
private 私有 可以修饰属性与方法
如果一个属性使用了private修饰，那么这个属性只能在本类内使用。
好处：
将变化隔离。
便于使用。
提高重用性。
提高安全性。
封装原则:将类中的不对应显示的属性private，对外提供公共的访问方式.提供一些 get/set方法去操作类中的属性。
语法规则:
get/set后面接属性名，属性首字母要大写。
如果是boolean类型的属性，它的get方法一般叫isXxx
get方法完成的是取值操作，get方法有返回值
set方法是完成赋值操作，set方法有参数
举例:
class Demo9 {
public static void main(String[] args) {
Person p=new Person();
//p.money=100;
//System.out.println(p.money);
p.setMoney(100);
System.out.println(p.getMoney());
//p.age=1000; //直接操作了对象的age属性，对堆内存中的值进行了操作。
p.setAge(1000);
}
}
class Person
{
private double money;
private int age;
private boolean marry;
public void setMarry(boolean marry){
this.marry=marry
}
public boolean isMarry(){
return marry;
}
public void setMoney(double m){
money=m;
}
public double getMoney(){
return money;
}
public void setAge(int a){
if(a>10&&a<80){
age=a;
}
}
public int getAge(){
return age;
}
}
五.构造方法(函数)
构造方法的作用
构造方法是用来创建对象.
注意:1.当我们创建一个类的对象时，必须查看这个类对外提供什么样的构造方法。
2.构造方法不能由程序调用
如果一个类中没有人为的创建构造方法，当这个类加载时jvm会自动为这个类创建一个默认的构造方法。
如果我们人为的手写了一个构造方法，那么默认构造就不会在创建.
构造方法格式
1.构造方法名必须与类名相同(大小写不能错)
2.构造方法没有返回值类型，void也没有。
3.构造方法没有修饰符，但是权限修饰符除外.
创建对象
类名 引用=new 构造方法();
构造方法可以重载
构造方法重载有什么好处?
为我们提供了多种途径去实例这个类的对象.
重载的构造方法的参数有什么用?
我们在创建对象时，可以通过构造方法的参数对对象的属性进行操作。
六.this关键字
this作用:代表本类对象
this在开发中最常见的应用:用来区*部变量与成员变量.
如果成员变量与局部变量没有重名，this可以省略.
this关键字存在的位置
1.成员方法 代表的是当前调用这个方法的对象
2.构造方法 代表的是当前构造正在创建的对象．
⑦基础小练习:
做出一副扑克牌(不包含大小王)
代码:
class Test3
{
public static void main(String[] args)
{
//通过无参数构造创建
/*
Poker p=new Poker();
p.setColor("红桃");
p.setNumber("10");
*/
//通过有参构造创建
//Poker p=new Poker("红桃","10");
//p.color="红桃";
//p.number="10";
//System.out.println(p.getColor()+p.getNumber());
//花色
String[] cs={"红桃","黑桃","方块","梅花"};
//值
String[] ns={"A","2" ,"3","4" ,"5", "6","7", "8", "9", "10", "J","Q", "K"};
//描述扑克盒
Poker[] ps=newPoker[cs.length*ns.length];
int index=0;//用来控制ps数组中的每一张扑克牌的下标。
for(inti=0;i<cs.length;i++){//控制花色
for(intj=0;j<ns.length;j++){//控制值
//ps[index]=newPoker(cs[i],ns[j]);
ps[index]=newPoker();
ps[index].setColor(cs[i]);
ps[index].setNumber(ns[j]);
index++;
}
}
for(inti=0;i<ps.length;i++){
if(i%ns.length==0){
System.out.println();
}
ps[i].show();
}
}
}
class Poker
{
private String color;//花色
private String number;//值
//无参构造
Poker(){
}
//有参构造 参数代表的是扑克的花色与值
Poker(String color,String number){
//在构造方法中使用this 因为Poker构造方法中的局部变量color,number与类中的成员变量重名。
this.color=color;
this.number=number;
}
//color属性的set方法
public void setColor(String color){
this.color=color;
}
//number属性的set方法
public void setNumber(String number){
this.number=number;
}
//color属性的get方法
public String getColor(){
return color;
}
//number属性的get方法
public String getNumber(){
return number;
}
//用来显示扑克内容
void show(){
System.out.print(color+number+"");
}
}
------- android培训、java培训、期待与您交流！ ----------