---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------
面向对象
在Java中，高手们的概念就是万物皆对象。
面向对象的概念：
面向对象和面向过程：面向对象：是基于面向过程的一种思想。
面向过程：强调的是功能行为。
面向对象：将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。
例如：开门
我们想开门，就是在指挥门的打开功能。
具体开门的动作是门自动完成的，具体门是怎么完成开门动作的，我们不管。因为它具备打开的功能，我们想开门，只要调用它的打开功能，只要结果。
例2：服务员
当我们去饭管吃饭的时候，我们要叫服务员点餐，我们只要说出菜的名称，服务员就把菜单拿给厨师去做，厨师就具备炒菜的功能，炒完后我们只要看这菜能吃，就行。
我们想吃这个菜就是过程。具体怎么做出来的就是过程。
图例：
面向对象有三个特征：封装，继承，多态
以后的开发过程：其实就是找对象用。没有对象，就创建一个对象。
找对象，建立对象，使用对象，并维护对象的关系。
类与对象的关系
类：就是对现实生活中事物的描述。
对象：就是这类事物，实实在在存在的个体。
想要描述：提取对象*性内容。对具体的抽象。
映射到Java中描述就是class定义的类。
具体对象就是对应Java在堆内存中用new建立实体。
例子：
需求：描述小汽车。描述事物其实就是在描述事情的属性和行为。
分析：
1、属性：轮胎数。颜色。
2、行为： 运行。
定义类其实就是在定义类中的成员。（成员：成员变量<-->属性，成员函数<-->行为。）
属性对应是类中变量，行为对应的类中函数或方法。
其实定义类，就是在描述事物，就是在定义属性和方法，属性和行为共同成为类中的成员（成员变量和成员方法）。
类中不必有主函数，不必保证独立运行,只有保证有一个主函数入口调用类就行。
成员变量和局部变量的区别。
作用范围。
成员变量作用于整个类中。
局部变量变量作用于函数中，或者语句中。
在内存中的位置：
成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。
*/
成员变量：
• 成员变量定义在类中，在整个类中都可以被访问。
• 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
• 成员变量有默认初始化值。
局部变量：
• 局部变量只定义在局部范围内，如：函数内，语句内等。
• 局部变量存在于栈内存中。
• 作用的范围结束，变量空间会自动释放。
• 局部变量没有默认初始化值。
面向对象在内存中的结构
public class _02Car对象 {
public static void main(String[] args)
{
//生产汽车就是在Java中通过new操作符来完成
//其实就是在堆内存中产生一个实体
Car c = new Car();
c.color="Blue";
c.run();
}
}
//创建对象
class Car
{
//定义成员变量
String color = "red";
int num = 4;
//定义对象方法
void run()
{
System.out.print("车是"+color+"色的，有"+num+"个车胎");
}
}
匿名对象，没有名字的对象 。
new Car();//匿名对象。其实就是对象的简写格式。
1、当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
2、匿名对象可以作为实际参数进行传递。
注意:调用匿名对象的属性是没有意义。
封装
封装：是指隐藏对象的属性和实现细节，仅对外提供 公共访问方式。
好处：
• 将变化隔离。
• 便于使用。
• 提高重用性。
• 提高安全性。
封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性都隐藏，提供公共方法对其访问。
举例：键盘：
我们只要会使用键盘上的键，敲出我们需要的 文字 就可以了，至于键盘里面是什么构造，怎么实现我们敲出字来，这个我们就不用思考了，简称：封装
private(私有)关键字
private关键字：
• 是一个权限修饰符。
• 用于修饰成员(成员变量和成员函数)
• 被私有化的成员只在本类中有效。
常用之一：
• 将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。
/*
* Private：私有权限修饰符。用于修饰类中的成员（成员变量，成员函数）
* 私有只在本类中有效
*
* 将age成员私有化后，类以外即使建立了对象，也不能直接访问
* 但人该有年龄，就需要在Person类中提供对应访问的age变量
*
* 注意：私有仅仅是封装的一种表现形式
* 之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断语句，对访问数据操作
* 提高代码的健壮性。
*/
class Person
{
//年龄
private int age;//私有变量
//赋值
public void setAge(int x)//setAge没有返回值，而且要进行传参
{
if(x>0 && x<130)
{
age = x;
Speak();//判断成功，输出
}
else
{
System.out.print("输入有误，重新输入！");
}
}
//取值
public int getAge()
{
return age;
}
//人的语言功能
void Speak()
{
System.out.print("我今年"+age+"岁了");
}
}
public class _04封装Private {
public static void main(String[] args)
{
Person p = new Person();
p.setAge(222);//传值
}
}
构造函数：
构造函数特点：
1、 函数名与类名相同。
2、不用定义返回值类型。
3、没有具体的返回值。
构造函数：构建创造对象时调用的函数。
构造函数作用：给对象进行初始化。
创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
注意：
1、 默认构造函数的特点。
2、多个构造函数是以重载的形式在在的。
一般函数和构造函数什么区别呢？
构造函数：对象创建时，就会调用与之对应的构造函数，给对象进行默认初始化。
一般函数：对象创建后，需要函数功能时才调用。(函数只有被调用才执行)
构造函数：对象创建时，只调用一次。
一般函数：对象创建后，可以被调用多次。
什么时候定义构造函数呢？
在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。
构造函数可以有多个，用于对不同的对象进行针对性的初始化。
多个构造函数在类中是以重载的形式来体现的。
构造函数的小细节：
当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数Person(){}
当在类中自定义了构造函数后，默认的构造函数就没有了
//下面定义“构造函数”
class PersonOne
{
//定义私有成员变量
private String name;
private int age;
//定义构造函数
PersonOne() //始初化函数
{
System.out.println("姓名="+name+",年龄="+age);
}
PersonOne(String a)
{
name = a;
System.out.println("姓名="+name+",年龄="+age);
Say();//调用功能
}
//Get Set 什么时候用？例如：想改孩子出生时的名字时
public void setName(String x)
{
name = x;
}
public String getName()//这个带返回值
{
return name;
}
PersonOne(String a,int b)
{
name = a;
age = b;
System.out.println("姓名="+name+",年龄="+age);
Say();//调用功能
}
//下面定义功能
void Say()
{
System.out.println("cry");
}
}
public class _05面向对象_构造函数
{
public static void main(String[] args)
{
PersonOne p1 = new PersonOne();
PersonOne p2 = new PersonOne("张三");
PersonOne p3 = new PersonOne("李四",22);
}
}
this：关键字
特点：this代表其所在函数所属对象的引用。
换言之：this代本类对象的引用。
什么时候使用this关键字呢？
当在函数内需要用到调用该函数的对象时，就用this。
当成员变量和局部变量重名，可以用关键字this来区分。
this：代表对象。代表哪个对象呢？当前对象。
this：就是所在函数所属对象的引用。
简单说：哪个对象调用了this所在的函数，this就代表哪个对象。
/*
* this 它所在函数所属对象的引用
* 白话说：哪个函数在调用this所在的函数，this就代表哪个对象
*/
class PersonThree
{
private String name;
private int age;
PersonThree()
{
System.out.println("名字："+this.name+"，年龄是："+this.age);
}
PersonThree(String name)
{
this.name = name;
System.out.println("名字："+this.name+"，年龄是："+this.age);
}
PersonThree(String name,int age)
{
this.name = name;
this.age = age;
System.out.println("名字："+this.name+"，年龄是："+this.age);
this.Say();//也可以加this
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void Say()
{
System.out.print("说话功能");
}
}
public class _07this关键字 {
public static void main(String[] args)
{
PersonThree p = new PersonThree("zhangsan");
PersonThree p1 = new PersonThree("lisi",22);
}
}
this在构造函数中的应用
/*
* this语句 用于构造函数之间，相互调用
* this语句只能定义在构造函数的第一行，因为初始化要先执行。
*/
class PersonFor
{
private String name;
private int age;
PersonFor()
{
this("haha");
}
PersonFor(String name)
{
this.name=name;
}
PersonFor(String name,int age)
{
this(name);
this.age=age;
}
void print()
{
System.out.println("名字："+name+"年龄："+age);
}
}
public class _08this在构造函数中的调用 {
public static void main(String[] args)
{
PersonFor p1 = new PersonFor();
PersonFor p2 = new PersonFor("张三",22);
p1.print();
p2.print();
}
}
静态Static
静态Static 什么时候使用？
/*
静态修饰的内容可以被对象共享。
静态的好处？可以节省内存空间，不用每个对象都去创建一份相同的引用。例如：国家。
* 什么时候使用静态？
*
* 要从两方面下手：
* 因为静态修饰的内容有成员变量和函数。
* 什么时候定义静态变量呢？
* 当对象中出现共享数据时，（例如：同属一个国家：中国）该数据被静态所修饰。
* 对象中特有的数据要定义成非静态存在于堆内存中。
*
* 什么时候定义静态函数呢？
* 当功能内部没有访问到非静态数据时，（对象的特有数据）
* 那么该功能可以定义成静态的。
*/
class Person
{
String name;
//直接调用方法功能
public static void Show()
{
System.out.println("haha");
}
}
public class _03静态Static什么时候用 {
public static void main(String[]args)
{
//创建对象的方式 调用方法
Person P = new Person();
P.Show();
//不创建对象的方式调用
Person.Show();//无需new一个对象，直接调用静态方法功能（这样可以节省内存）
}
}
静态代码块
/*
* 静态代码块：格式
* static
* {
* 静态代码块的执行语句
* }
*
* 静态代码块特点：随着类的加载而加载。只执行一次。（并优先于主函数执行）
* 白话是：程序一执行起来，先对静态代码块执行，所有的静态代码块执行完成后，再执行主函数
* 对类进行初始化。
*/
class StaticCode
{
/*小知识点：
int num=9;
static
{
System.out.println("后面不能加gum，因为静态成员只能访问静态变量！"+num);
}
*/
static
{
System.out.println("a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行");
}
{
System.out.println("e..构造代码块，给对象初始化的。");
}
StaticCode(int x)
{
System.out.println("f..构造函数，给对应对象初始化的");
} //这个后面可以加上面的num;因为它是对象的初始化，所以可以访问成员变量
}
public class _05静态代码块 {
static
{
System.out.println("b..对类进行初始化。");
}
public static void main(String[]args)
{
///new StaticCode();
//new StaticCode(); //new两个对象，但在程序中只执行了一次。
new StaticCode(4);//进行传递参数
System.out.println("over");
}
static
{
System.out.println("c");
}
}
/*
* 上面代码的执行顺序是：
*b..对类进行初始化。
c
a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行
e..构造代码块，给对象初始化的。
f..构造函数，给对应对象初始化的
over
*/
---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------