总结1：面向对象

1:面向对象
(1)面向对象是相对于面向过程而言的一种思想。
面向过程：完成功能的步骤。
面向对象：结果。通过对象，调用功能。


A:是一种更符合人们思考习惯的一种思想。
B:把复杂的问题简单化了。
C:让我们从执行者变成了指挥者。


举例：
A:买电脑
B:吃饭
C:洗衣服
(2)把大象装进冰箱：
面向过程：
A:打开冰箱门
B:把大象装进去
C:关闭冰箱门


代码体现：
public class Test
{
public static void main(String[] args)
{
//System.out.println("打开冰箱门");
//System.out.println("把大象装进去");
//System.out.println("关闭冰箱门");


open();
in();
close();
}


public static void open()
{
System.out.println("打开冰箱门");
}


public static void close()
{
System.out.println("关闭冰箱门");
}


public static void in()
{
System.out.println("把大象装进去");
}
}


面向对象：
A:分析这个需求中有哪些类。
B:分析每个类有哪些成员。
C:分析类与类之间的关系。


分析：
A:哪些类? 名词提取法。(UML统一建模语言 设计模式)
大象:
冰箱:
测试类：
B:哪些成员?
大象:
in()
冰箱:
open()
close()
测试类：
main()
C:关系?
在测试类里面创建大象和冰箱的对象调用功能即可。


代码体现：

public class 大象
{
public void in()
{
System.out.println("把大象装进去");
}
}


public class 冰箱
{
public void open()
{
System.out.println("打开冰箱门");
}


public void close()
{
System.out.println("关闭冰箱门");
}
}


public class Test
{
public static void main(String[] args)
{
冰箱 b = new 冰箱();
大象 d = new 大象();


b.open();
d.in();
b.close();
}
}


2:类和对象
(1)java语言是用来对现实世界的事物进行模拟的。

(2)现实世界的事物
外在的特征
事物的行为


(3)java语言的最基本单位是：类
类来体现事物：
成员变量 -- 外在的特征
成员方法 -- 事物的行为
(4)案例：手机事物
手机事物：
外在的特征 
品牌,价格,颜色...
事物的行为
打电话,发短信,...


手机类：
成员变量
品牌,价格,颜色...
成员方法
打电话,发短信,...


代码体现：
public class Phone
{
//手机品牌
private String type;
//手机价格
private float price;
//手机颜色
private String color;


public void call(String name)
{
System.out.println("给"+name+"打电话");
}


public void sendMessage(String name)
{
System.out.println("给"+name+"发短信");
}
}


规则：成员变量private,成员方法public
(5)如何使用代码：
类：就是一类事物的抽象。
对象：是该类事物的具体体现。


对象怎么来的呢?
通过new关键字,在内存中申请空间,然后创建了一个对象。
格式：
类名 变量 =  new 类名();


构造方法：默认有无参构造。


public class PhoneTest
{
public static void main(String[] args)
{
//创建对象
Phone p = new Phone();


p.call("林青霞");
p.sendMessage("林青霞");
}
}


3:封装
(1)隐藏实现细节,提供公共的访问方式
(2)代码体现：private关键字的使用

学生类：
成员变量：姓名,年龄
成员方法：学习,睡觉
构造方法：无参,带参


public 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; //隐含this
}


public void setAge(int age)
{
this.age = age;
}


public int getAge()
{
return age;
}
}
(3)构造方法
A:特点
与类名相同,没有返回值及返回类型
B:注意：
a:如果你不给,系统会默认给出一个无参构造
b:如果你给出了构造,系统将不会再产生一个无参构造。
 如果你不使用无参构造，没有问题。
 如果你要使用，请自己手动给出。
 
推荐：永远自己给出无参构造。
(4)this关键字
A:代表当前对象的引用。谁调用，它代表谁。
B:使用场景：
a:用于解决局部变量隐藏成员变量。
b:在一个方法中代表当前对象。
c:用在构造方法中调用本类的其他构造方法。(一般不用)
(5)如何给成员变量赋值
A:构造方法
Student s = new Student("林青霞",26);
B:set方法
Student s = new Student();
s.setName("王祖贤");
s.setAge(20);


推荐：set方法


4:继承
(1)java中提供了一种创建类的机制，在定义类的时候，不需要所有的内容都重新开始，
  可以在一定的基础上进行创建类。这种机制叫继承。


  举例：
  public class Student
  {
public void study(){System.out.println("学习");}
  }


  public class Teacher
  {
public void study(){System.out.println("学习");}
  }


  发现了一个问题，代码的重复度太高了，怎么办呢?
  我们就想出了一个方案，首先定义一个类，把所有相同的成员都定义在里面。
  最后，在定义其他类的的时候，让他们之间产生一个关系。有了这个关系，
  其他的类就不需要再定义已经定义过的成员。这个关系：继承。


(2)通过继承改进上面的代码
  public class Person
  {
public void study(){System.out.println("学习");}
  }


  public class Student extends Person{}
  public class Teacher extends Person{}


(3)好处：
A:提高了代码的复用性。
B:让类与类之间产生了关系,是多态的前提。
(4)注意：
A:java中只能单继承。
B:java中可以多层继承。
(5)方法的重写
在子父类中，方法声明相同。推荐：声明一模一样。


5:抽象类与接口
看代码：
  public class Student
  {
public void study(){System.out.println("学习知识");}
  }


  public class Teacher
  {
public void study(){System.out.println("学习怎么讲的更好");}
  }
这个时候，我们还可以通过继承体现吗?不能。
但是，我们可以只抽取方法的声明，不实现。


(1)代码体现：
public abstract class Person
{
public abstract void study();


//code 10个非抽象方法...
}


public class Student extends Person
{
public void study(){System.out.println("学习知识");}
}


public class Teacher extends Person
{
public void study(){System.out.println("学习怎么讲的更好");}
}
(2)抽象类注意：
A:当一个方法没有方法体,这个方法就必须用抽象修饰。
B:当一个类中有抽象方法的时候,这个类必须被定义为抽象类。
C:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类。
面试题：如果一个类中没有抽象方法，那么这个类被定义为抽象类有什么用?
就是为了不让创建对象。
(3)这个时候，我们没有看到代码被优化了，那么，为什么还会出现抽象类?
A:在抽象类中是可以有非抽象方法的。
B:抽象类可以强制要求子类必须重写某些方法。



(4)接口：
当抽象类中的方法都是抽象的时候，java又提供了一种新的机制，叫接口。
interface:接口
implements:实现


public interface Person
{
public abstract void study();
}


public class Student implements Person
{
public void study(){System.out.println("学习知识");}
}


public class Teacher implements Person
{
public void study(){System.out.println("学习怎么讲的更好");}
}
(5)接口出现后，我们的继承和实现关系如下：
类与类：
继承关系,只能单继承。可以多重继承。
类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类同时实现多个接口。
接口与接口：
继承关系,可以单继承,也可以多继承。


6:抽象类与接口的区别?
(1)成员的区别?
抽象类：
成员变量：可以是变量,也可以是常量。
成员方法：可以是抽象的,也可以是非抽象的。
构造方法：有构造方法。用于子类实例化时候使用。
接口：
成员变量：只能是常量。
 默认修饰符：public static final
成员方法：只能是抽象方法
 默认修饰符：public abstract


推荐：自己手动给出。
(2)接口的出现避免了单继承的局限性。
(3)设计理念不用
  抽象类被继承是"is a"的关系,并且里面定义的一般都是类的共性内容。
  接口被实现是"like a"的关系,一般定义的是类的扩张内容。
(4)作业：
  乒乓球运行员
  篮球运行员


  乒乓球教练
  篮球教练


  我们乒乓球为了出国交流,需要学习英语,请用你所学过的知识用代码体现我的需求。
  类,抽象类,接口


7:多态
(1)一个对象在不同时刻所表现出来的状态。
举例：水(固态,液态,气态)
     狗(狗,动物)
(2)如何体现多态呢?
A:有继承或者实现关系
B:有方法的重写
C:有父类或者父接口引用指向子类对象
(3)代码体现：
public class Fu
{
int num = 10;


public void show()
{
System.out.println("show Fu");
}
}


public class Zi extends Fu
{
int num = 20;


public void show()
{
System.out.println("show Zi");
}


public void method()
{
System.out.println("show method");
}
}


public class Test
{
public static void main(String[] args)
{
Fu f = new Fu();
System.out.println(f.num); //10
f.show();//show Fu


Zi zi = new Zi();
System.out.println(zi.num);//20
zi.show();//show Zi


//多态
Fu ff = new Zi();
System.out.println(ff.num);//10
ff.show();//show zi
//ff.method(); //编译报错
}
}
(4)多态中成员的使用：
成员变量：
编译看左边,运行看左边


成员方法：
编译看左边,运行看右边


为什么?
因为方法有重写。
(5)多态好处和弊端
A:好处 提高了代码的扩展性和可维护性
B:弊端 不能使用子类特有功能


public abstract class Animal
{
public abstract void eat();
}


public class Dog extends Animal
{
public void eat(){}
}


public class Cat extends Animal
{
public void eat(){}
}


测试类：
//Dog d = new Dog();
//Cat c = new Cat();


//d.eat();
//c.eat();




Animal a = new Dog();
a.eat();


a = new Cat();
a.eat();

//...
//要有哪些动物呢?我在这个时候并不明确。
//这里只需要留下动物即可,不需要留下具体的子类。
//但是，将来使用的时候，肯定要给一个具体的子类。
//所有父类出现过的地方，都可以直接使用子类替换。
(6)孔子装爹的故事：

孔子爹：教书("JavaSE"),age=40
孔子：教书("论语"),玩游戏(),age=20


//最近培训很火,有人来请孔子爹去讲课
孔子爹 k爹 = new 孔子(); //穿上爹的衣服,带上爹的眼镜,装爹 向上转型
k爹.教书(); //论语
System.out.println(k爹.age); //40
// 错误 k爹.玩游戏();


//一天忙碌的课程下来了
孔子 k = (孔子)k爹;  //向下转型 回家了,去掉爹的服饰
k.教书();//论语
k.玩游戏();
System.out.println(k.age); //20