（二）黑马程序员——面向对象

------- <a href="http://www.itheima.com" target="blank">android培训</a>、

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

早期的程序经历了面向问题和面向过程的阶段，随着计算机的发展以及解决问题的复杂性的提高，以往的程序设计方法已经不能适应现代的软件技术要求，于是，从20世纪70年代开始，相继出现了多种面向对象的程序设计语言，像C++、Smalltalk、Java等都是比较熟知的符合面向对象设计的语言。

Java面向对象的三大特性：

封装性 ， 继承性，多态

封装性：

封装是面向对象的方法所应遵循的一个重要原则，它有两个含义，一是指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位中；另一层含义指“信息隐蔽”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知晓；或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节。 封装机制在程序设计中表现为，把描述对象属性的变量及实现对象功能的方法合在一起，定义为一个程序单位，并保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法。 封装机制的另一个特点是，为封装在一个整体内的变量及方法规定了不同级别的“可见性”或访问权限。

继承性：

继承是面向对象方法中的重要概念，并且是提高软件开发效率的重要手段。首先拥有反映事物一般特性的类，然后在其基础上派生出反映特殊事物的类。如已有的汽车的类，该类中描述了汽车的普遍属性和行为，进一步再产生轿车的类，轿车的类是继承于汽车类，轿车类不但拥有汽车类的全部属性和行为，还增加轿车特有的属性和行为。 
在Java程序设计中，已有的类可以是Java开发环境所提供的一批最基本的程序——类库。用户开发的程序类是继承这些已有的类。这样，现在类所描述过的属性及行为，即已定义的变量和方法，在继承产生的类中完全可以使用。被继承的类称为父类或超类，而经继承产生的类称为子类或派生类。根据继承机制，派生类继承了超类的所有成员，并相应地增加了自己的一些新的成员。 
面向对象程序设计中的继承机制，大大增强了程序代码的可复用性，提高了软件的开发效率，降低了程序产生错误的可能性，也为程序的修改扩充提供了便利。 
若一个子类只允许继承一个父类，称为单继承；若允许继承多个父类，称为多继承。目前许多面向对象程序设计语言不支持多继承。而Java语言通过接口（interface）的方式来弥补由于Java不支持多继承而带来的子类不能享用多个父类的成员的缺憾。

多态性：

多态是面向对象设计语言的基本特征。仅仅是将数据和方法捆绑在一起，进行类的封装，使用一些简单的继承，还不能算是真正应用了面向对象的设计思想。多态性是面向对象的精髓。多态性可以简单地概括为“一个接口，多种方法”。 
多态性是指同名的方法可在不同的类中具有不同的运动规律。在父类演绎为子类时，类的运动规律也同样可以演绎，演绎使子类的同名运动规律或运动形式更具体，甚至子类可以有不同于父类的运动规律或运动形式。不同的子类可以演绎出不同的运动规律。如动物都会吃，而羊和狼吃的方式和内容都不一样。如：警车鸣笛，普通人反应一般，逃犯听见会大惊失色。警车鸣笛（同一种行为），导致普通人和逃犯不同反应(多种形态)。再如，画出昆虫的图片，对蚂蚁和对蜘蛛这2种昆虫画出的是不同的图片。通常是指对于同一个消息、同一种调用，在不同的场合，不同的情况下，执行不同的行为。 
Java语言中含有方法重载与成员覆盖两种形式的多态。 
方法重载：也叫静态多态。在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。 
成员覆盖：也叫动态多态。子类与父类允许具有相同的变量名称，但数据类型不同，允许具有相同的方法名称，但完成的功能不同。

面向对象(构造方法Constructor概述和格式)

* A:构造方法概述和作用

* 给对象的数据(属性)进行初始化

* B:构造方法格式特点

* a:方法名与类名相同(大小也要与类名一致)

* b:没有返回值类型，连void都没有

* c:没有具体的返回值return;

案例：

class Demo1_Constructor {//Constructor构造
public static void main(String[] args) {
Person p = new Person();//在一创建对象的时候,系统就帮我调用了构造方法
//p.Person();//构造方法不能用对象调用
p.show();
 
Person p2 = new Person();//再次创建对象
p2.show();
}
}

class Person {
private String name;
private int age;
 
//构造方法
public Person() {
//System.out.println("Hello World!");
//return;//构造方法也是有return语句的,格式是return;
name = "张三";
age = 23;
}
 
public void show() {
System.out.println(name + "..." + age);
}
}

面向对象(构造方法的重载及注意事项)

* A:案例演示

* 构造方法的重载

* 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

* B:构造方法注意事项

* a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

* b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。

* 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

案例：

class Demo2_Person {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
 
System.out.println("---------------------");
 
Person p2 = new Person("张三",23);
p2.show();
 
System.out.println("---------------------");
 
Person p3 = new Person("李四",24);
p3.show();
}
}
class Person {
private String name;//姓名
private int age;//年龄
 
public Person() {//空参构造
System.out.println("空参的构造");
}
 
public Person(String name,int age) {
this.name = name;
this.age = age;
System.out.println("有参的构造");
}
public void show() {
System.out.println(name + "..." + age);
}
}

面向对象(给成员变量赋值的两种方式的区别)

* A:setXxx()方法

* 修改属性值 

* B:构造方法

* 给对象中属性进行初始化 

案例：

class Demo3_Person {
public static void main(String[] args) {
Person p1 = new Person("张三",23);
//p1 = new Person("张天一",23);//这种方式看运行结果貌似是改名了,其实是将原对象变成垃圾
System.out.println(p1.getName() + "..." + p1.getAge());
 
System.out.println("--------------------");
Person p2 = new Person();//空参构造创建对象
p2.setName("李四");
p2.setAge(24);
 
p2.setName("李鬼");
System.out.println(p2.getName() + "..." + p2.getAge());
}
}
class Person {
private String name;//姓名
private int age;//年龄
 
public Person() {//空参构造
}
 
public Person(String name,int age) {//有参构造
this.name = name;
this.age = age;
}
public void setName(String name) {//设置姓名
this.name = name;
}
 
public String getName() {//获取姓名
return name;
}
 
public void setAge(int age) {//设置年龄
this.age = age;
}
 
public int getAge() {//获取年龄
return age;
}
}

面向对象(学生类的代码及测试)

* A:案例演示

* 学生类：

* 成员变量：

* name，age

* 构造方法：

* 无参，带两个参

* 成员方法：

* getXxx()/setXxx()

* show()：输出该类的所有成员变量值

* B:给成员变量赋值：

* a:setXxx()方法

* b:构造方法

* C:输出成员变量值的方式：

* a:通过getXxx()分别获取然后拼接

* b:通过调用show()方法搞定

案例：

class Demo4_Student {
public static void main(String[] args) {
Student s1 = new Student();//使用空参构造
s1.setName("张三");//设置姓名
s1.setAge(23);//设置年龄
 
System.out.println("我的姓名是:" + s1.getName() + ",我的年龄是:" + s1.getAge());
//getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
Student s2 = new Student("李四",24);
s2.show();//只是为了显示属性值
}
}
class Student {
private String name;//姓名
private int age;//年龄
 
public Student(){}//空参构造
 
public Student(String name,int age) {//有参构造
this.name = name;
this.age = age;
}
 
public void setName(String name) {//设置姓名
this.name = name;
}
 
public String getName() {//获取姓名
return name;
}
 
public void setAge(int age) {//设置年龄
this.age = age;
}
 
public int getAge() {//获取年龄
return age;
}
 
public void show() {
System.out.println("我的姓名是:" + name +  ",我的年龄是:" +  age);
}
}

面向对象(手机类的代码及测试)

* A:案例演示

* 模仿学生类，完成手机类代码

案例：

class Demo5_Phone {
public static void main(String[] args) {
Phone p1 = new Phone();
p1.setBrand("苹果");
p1.setPrice(1500);
System.out.println(p1.getBrand() + "..." + p1.getPrice());
 
Phone p2 = new Phone("小米",98);
p2.show();
}
}
class Phone {
private String brand;//品牌
private int price;    //价格
 
public Phone(){}//空参构造
 
public Phone(String brand,int price) {//有参构造
this.brand = brand;
this.price = price;
}
 
public void setBrand(String brand) {//设置品牌
this.brand = brand;
}
 
public String getBrand() {//获取品牌
return brand;
}
 
public void setPrice(int price) {//设置价格
this.price = price;
}
 
public int getPrice() {//获取价格
return price;
}
 
public void show() {
System.out.println(brand + "..." + price);
}
}

面向对象(创建一个对象的步骤)

* Student s = new Student();

* 1,Student.class加载进内存

* 2,声明一个Student类型引用s

* 3,在堆内存创建对象,

* 4,给对象中属性默认初始化值

* 5,属性进行显示初始化

* 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈

* 7,将对象的地址值赋值给s

案例：

class Demo1_Student {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
 
class Student {
private String name = "张三";
private int age = 23;
 
public Student() {
name = "李四";
age = 24;
}
 
public void show() {
System.out.println(name + "..." + age);
}
}

面向对象(static关键字)

* 通过一个案例引入static关键字。

* 人类：Person。每个人都有国籍，中国。

class Demo1_Static {
public static void main(String[] args) {
/*Person p1 = new Person();//创建对象
p1.name = "苍老师";//调用姓名属性并赋值
p1.country = "日本";//调用国籍属性并赋值
 
Person p2 = new Person();
p2.name = "小泽老师";//调用姓名属性并赋值
//p2.country = "日本";//调用国籍属性并赋值
 
p1.speak();
p2.speak();*/
 
Person.country = "日本";//静态多了一种调用方式,可以通过类名.
System.out.println(Person.country);
}
}
 
class Person {
String name;//姓名
static String country;//国籍
 
public void speak() {//说话的方法
System.out.println(name + "..." + country);
}
}

面向对象(static关键字的特点)

* A:static关键字的特点

* a:随着类的加载而加载

* b:优先于对象存在：随着字节码文件的加载而加载的，那时候还没有对象呢！

* c:被类的所有对象共享

* 举例：咱们班级的学生应该共用同一个班级编号。

* 其实这个特点也是在告诉我们什么时候使用静态?

* 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

* 举例：

* 饮水机(用静态修饰)

* 水杯(不能用静态修饰)

* 共性用静态,特性用非静态

* d:可以通过类名调用

* 其实它本身也可以通过对象名调用。

* 推荐使用类名调用。

* 静态修饰的内容一般我们称其为：与类相关的，类成员（静态变量：类变量，静态方法：类方法）

* B:案例演示

* static关键字的特点

面向对象(static的注意事项)

* A:static的注意事项

* a:在静态方法中是没有this关键字的(因为this指的是一个具体的对象,而静态在加载到内存时还没有具体的对象)

* 如何理解呢?

* 静态是随着类的加载而加载，this是随着对象的创建而存在。

* 静态比对象先存在。

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

* 静态方法：

* 成员变量：只能访问静态变量

* 成员方法：只能访问静态成员方法

* 非静态方法：

* 成员变量：可以是静态的，也可以是非静态的

* 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。

* 简单记：

* 静态只能访问静态。

* B:案例演示

* static的注意事项

案例：

class Demo2_Static {
public static void main(String[] args) {
//Demo d = new Demo();
//d.print1();
 
Demo.print2();
}
}
class Demo {
int num1 = 10;//非静态的成员变量
static int num2 = 20;//静态的成员变量
 
/*public void print1() {//非静态的成员方法,既可以访问静态的成员也可以访问非静态的
System.out.println(num1);
System.out.println(num2);
}*/
 
public static void print2() {//静态的成员方法
//System.out.println(this.num1);//静态的成员方法不能访问非静态的,错误: 无法从静态上下文中引用非静态 变量 num1
System.out.println(num2);
}
}

面向对象(静态变量和成员变量的区别)

* 静态变量也叫类变量  成员变量也叫对象变量

* A:所属不同

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

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

* B:内存中位置不同

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

* 成员变量存储于堆内存

* C:内存出现时间不同

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

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

* D:调用不同

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

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

面向对象(main方法的格式详细解释)

* A:格式

* public static void main(String[] args) {}

* B:针对格式的解释

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

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

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

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

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

* C:演示案例

* 通过args接收键盘例如数据

class Demo3_Main {
public static void main(String[] args) {
System.out.println(args.length);
for (int i = 0;i < args.length ;i++ ) {
System.out.println(args[i]);
}
}
}

面向对象(代码块的概述和分类)

* A:代码块概述

* 在Java中，使用{}括起来的代码被称为代码块。

* B:代码块分类

* 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

        局部代码块：只要是和局部有关系的，都是和方法有关系的

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

* C:常见代码块的应用

* a:局部代码块 

* 在方法中出现；限定变量生命周期，及早释放，提高内存利用率

* b:构造代码块 (初始化块)

* 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

* c:静态代码块 

* 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

* 一般用于加载驱动

案例：

class Demo1_Code {
public static void main(String[] args) {
{z
int x = 10;//限定变量的周期
System.out.println(x);
}
Student s1 = new Student();
System.out.println("---------------");
Student s2 = new Student("张三",23);
}
 
static {
System.out.println("我是在主方法类中的静态代码块");
}
}
 
class Student {
private String name;
private int age;
 
public Student(){
//study();
System.out.println("空参构造");
}//空参构造
 
public Student(String name,int age) {//有参构造
//study();
this.name = name;
this.age = age;
System.out.println("有参构造");
}
 
public void setName(String name) {
this.name = name;
}
 
public String getName() {
return name;
}
 
public void setAge(int age) {
this.age = age;
}
 
public int getAge() {
return age;
}
 
{//构造代码块:每创建一次对象就会执行一次,优先于构造函数执行
//System.out.println("构造代码块");
study();
}
 
public void study() {
System.out.println("学生学习");
}
 
static {//随着类加载而加载,且只执行一次
System.out.println("我是静态代码块");//作用:用来给类进行初始化,一般用来加载驱动
}//静态代码块是优先于主方法执行
}

面向对象(代码块)

案例：

class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class Demo2_Student {
static {
System.out.println("Demo2_Student静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}

运行结果：

Demo2_Student静态代码块

我是main方法

Student 静态代码块

Student 构造代码块

Student 构造方法

Student 构造代码块

Student 构造方法