黑马程序员之 --- 面向对象上

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

面向对象思想：面向对象是基于面向过程的编程思

就比如说我们敲代码：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。

在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。

那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

面向过程的代表语言：C语言

在用面向对象思想体现的时候，给出一个三句话使用规则，让我们更符合面向对象思想

A:首先分析有那些类

B:接着分析每个类应该有什么

C:最后分析类与类的关系

面向对象思想特点:

是一种更符合我们思想习惯的思想

可以将复杂的事情简单化

将我们从执行者变成了指挥者

面向对象特征

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

类与对象：

类：是一组相关的属性和行为的集合，抽象的概念（可以理解为构造对象的一个蓝图或者模版）

对象：是以类为模型创建的具体实例，是对类的一种具体化

举例：

类     动物

对象 猫就是一个对象

如何创建对象呢？

格式： 类名 对象名 = new 类名();

怎么使用对象呢？

通过对象名.成员 的方式使用

使用成员变量：

格式： 对象名.成员变量

使用成员方法：

格式： 对象名.成员方法();

注意：当一个java文件中有多个类class的时候，保存的名字要和包含主方法main()的类名一致

//测试类

class StudentTest {

public static void main(String[] args){

//创建一个学生对象

Student s = new Student();

//获取学生的成员变量值

System.out.println( "name="+s.name+", age="+s.age +", addresss=" + s.address );

//设置学生的成员变量值

s.name = "王小二";

s.age = 20;

s.address = "北京";

//获取学生的成员变量值

System.out.println( "name="+s.name+", age="+s.age +", addresss=" + s.address );

//调用成员方法

s.eat();

s.sleep();

s.study();

}

}

//定义一个学生类

class Student {

//定义成员变量： 就是事物的属性【姓名，年龄，地址】

//姓名

String name;

//年龄

int age;

//地址

String address;

//成员方法 就是事物的行为【学习、吃饭、睡觉】

//学习方法

public void study(){

System.out.println("我们正在开心的学习java");

}

//吃饭方法

public void eat(){

System.out.println("早上大家吃饭了吗？");

}

//睡觉

public void sleep(){

System.out.println("注意了，现在是上课期间，不能睡觉");

}

}

成员变量和局部变量的区别:

在类中的位置不同

成员变量 类中方法外

局部变量 方法内或者方法声明上

在内存中的位置不同

成员变量 堆内存

局部变量 栈内存

生命周期不同

成员变量 随着对象的存在而存在，随着对象的消失而消失

局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

成员变量 有默认的初始化值

局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

 

方法的形式参数是类名的时候如何调用:

形式参数：方法的参数列表中的参数

实际参数：调用方法时，传递的参数

基本数据类型：

形式参数的改变 对 实际参数没有影响

引用数据类型：

形式参数的改变 对 实际参数   有影响

class类型的参数，也属于引用数据类型

调用方式如下：

class Student {

public void study(){

System.out.println("正在复习中");

}

}

class Test {

public static void main(String[] args){

//创建Test对象

Test t = new Test();

Student s = new Student();

t.method( s );

}

public void method( Student s ){

//this --> t对象

s.study();

}

}

匿名对象: 就是没有名字的对象

是对象的一种简化表示形式

匿名对象的两种使用情况:

对象调用方法仅仅一次的时候

new Student().study();

作为实际参数传递

t.method( new Student() );

class Student {

public void study(){

System.out.println("大家注意听讲");

}

}

class StudentTest {

public void function(Student stu){

stu.study();

}

}

class Test {

public static void main(String[] args) {

//普通方式

Student s = new Student();

s.study();

s.study();

//匿名对象方式

new Student().study();

new Student().study();

//普通方式

StudentTest st = new StudentTest();

Student s2 = new Student();

st.function( s2 );

//匿名方式

st.function( new Student() );

//匿名对象方式

new StudentTest().function( new Student() );

}

}

封装:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：

隐藏实现细节，提供公共的访问方式

提高了代码的复用性

提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问

常见的封装：

private关键字修饰的成员

方法

类

包

private关键字: 私有的

private关键字：

是一个权限修饰符。

可以修饰成员(成员变量和成员方法)

被private修饰的成员只在本类中才能访问

this关键字:

this:代表所在类的对象引用

记住：

方法被哪个对象调用，this就代表那个对象

什么时候使用this呢?

局部变量隐藏成员变量

封装使用private、this的标准代码：

//定义一个学生类

class Student {

//成员变量

private String name;

private int age;

private String address;

//成员方法

//提供公共访问方法 setXxx() getXxx()

public void setName(String name){

this.name = name;

}

public String getName(){

return this.name;

//return name;

}

public void setAge(int age){

this.age = age;

}

public int getAge(){

return age;

}

public void setAddress(String address){

this.address = address;

}

public String getAddress(){

return address;

}

}

//测试类

class StudentTest {

public static void main(String[] args) {

//创建对象

Student s = new Student();

//赋值

s.setName("李科霈老师");

s.setAge(28);

s.setAddress("北京");

System.out.println( s.getName()+"..."+s.getAge()+"..."+s.getAddress() );

}

}     

构造方法

构造方法作用概述

在创建对象的时候，用来给对象中的成员的进行数据初始化

构造方法格式：

修饰符 类名(参数列表){...}

方法名与类名相同

没有返回值类型，连void都没有

没有具体的返回值

构造方法注意事项

如果你不提供构造方法，系统会给出空参数的构造方法

如果你提供了构造方法，系统将不再提供空参数的构造方法

构造方法也是可以重载的

class Phone {

//成员变量

String brand;//品牌

String color;//颜色

//构造方法

public Phone(){

System.out.println("这是一个空参数构造方法");

}

//在创建手机对象的时候，就给手机成员赋初始化值

//有参数的构造方法

//方法重载: 方法名相同，参数列表不同

public Phone(String brand, String color){

System.out.println("这是一个带有参数构造方法");

this.brand = brand;

this.color = color;

}

}

class PhoneTest {

public static void main(String[] args) {

//创建对象

Phone p = new Phone();

System.out.println("品牌为:" + p.brand + ",颜色为:"+ p.color);

//创建对象，并给初始化值

Phone p2 = new Phone("华为", "白色");

System.out.println("品牌为:" + p2.brand + ",颜色为:"+ p2.color);

}

}

成员方法的分类:

返回值：

有返回值的方法

没有返回值的方法

参数列表:

空参数方法

有参数方法

class Student {

//成员变量

String name;

int age;

//成员方法

//没有参数,没有返回值的方法

public void method1(){

System.out.println("method1");

}

//没有参数，有返回值的方法

public int getAge(){

return age;

}

//有参数，没有返回值的方法

public void setAge(int age){

this.age = age;

}

//有参数，有返回值的方法

public String show(String name, int age){

return name + "--" + age;

}

}

class StudentDemo {

public static void main(String[] args) {

//创建对象

Student s = new Student();

s.method1();

//把方法的返回值赋值给一个变量

int age = s.getAge();

System.out.println("age="+age);

//把方法的返回值，直接通过输出语句打印

System.out.println( s.getAge() );

//方法直接调用, 对于带有返回值的方法而言，这种调用方法没有意义

//s.getAge();

//没有返回值的方法，调用方式有那几种？

//只有一种，直接调用

//直接调用,赋值

s.setAge(20);

System.out.println( s.getAge() );

//有参数，有返回值的方法

String result = s.show("张三", 20);

System.out.println(result);

}

}

创建一个对象的步骤:

即  在内存中做了哪些事情

Student s = new Student();

加载Student.class文件进内存

在栈内存为s开辟空间

在堆内存为学生对象开辟空间

对学生对象的成员变量进行默认初始化

对学生对象的成员变量进行显示初始化

通过构造方法对学生对象的成员变量赋值

学生对象初始化完毕，把对象地址赋值给s变量

变量的定义

成员变量： 这个变量是否属于事物中的属性

特点：变量的使用范问越小越好

static关键字

可以修饰成员变量和成员方法

static关键字特点：

静态所修饰的成员，随着类的加载而加载，优先于对象存在

静态所修饰的成员，会被所有对象共享

可以通过类名调用

类名.静态成员

static关键字注意事项：

在静态方法中是没有this关键字的

静态方法只能访问静态的成员变量和静态的成员方法

静态只能访问静态

例题演示：

class Student {

String name = "王二狗";

int age = 30;

static String country = "中国";

//普通

public void method(){

//普通变量

System.out.println(name +"---"+age);

//静态变量

System.out.println(country);

//调用方法

method2();

function2();

}

//静态方法

public static void function(){

//普通变量

//System.out.println(name +"---"+age);//错误: 无法从静态上下文中引用非静态 变量 name

//System.out.println(this.name +"---"+this.age);

//静态变量

System.out.println(country);

//访问普通方法

//method2();//错误: 无法从静态上下文中引用非静态 方法 method2()

//访问静态方法

function2();

}

//普通方法

public void method2(){}

//静态方法

public static void function2(){}

}

class StudentDemo {

public static void main(String[] args) {

//创建对象

Student s = new Student();

s.method();

}

}

(面试题)静态变量和成员变量的区别

所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对象名调用

)main方法的格式详细解释

public 被jvm调用，访问权限足够大。

static 被jvm调用，不用创建对象，直接类名访问

void   被jvm调用，不需要给jvm返回值

main   一个通用的名称，虽然不是关键字，但是被jvm识别

String[] args 以前用于接收键盘录入的

工具类中使用静态

方便我们使用方法，无需创建对象，直接类名调用，方便

如何使用JDK提供的帮助文档

1：找到文档，打开文档

2：点击显示，找到索引，出现输入框

3：你应该知道你找谁?举例：Scanner

4：看这个类的结构(需不需要导包)

注意:如果这个类的包是java.lang; 在使用的使用就不需要导包操作，直接使用

由于，java.util.Scanner, 不是java.lang 在使用的时候就要导包使用

成员变量 字段摘要

构造方法 构造方法摘要

成员方法 方法摘要

看这个类的说明

看构造方法---> 构造方法摘要

看成员方法---> 方法摘要

然后使用

Math:数学工具类

public static double random(): 返回一个double类型的正数，范围在0.0<=x<1.0之间

得到1-100之间的随机整数

int num = (int)(Math.random()*100+1);        

猜字例题代码演示：

//导包

import java.util.Scanner;

 

class GuessNumberGame {

public static void main(String[] args) {

//1： 生成一个随机数整数 1-100

int random = (int)(Math.random()*100 +1);

System.out.println("请输入一个数[1-100]：");

int i=1;

while (true) {

//2:  键盘录入一个数

System.out.println("第"+i+"次");

Scanner sc = new Scanner(System.in);

int number  = sc.nextInt();

//3： 比较

if (number > random) {

System.out.println("猜大了，请往小了猜");

} else if( number < random) {

System.out.println("猜小了，请往大了猜");

} else {

System.out.println("恭喜你，猜对了，唱歌");

break;

}

i++;

if (i==20) {

System.out.println("对不起，您的智商不达标！！！");

break;

}

}

}

}