1:Java 面向对象:
- 所谓的面向对象是一种编程思想,通过这种思想可以把生活中的复杂事情变得简单化,从原来的执行者变成了指挥者,面向对象是基于面向过程而言的:
我们经常说过的面向对象的编程实现:[OOP, Object, Orientend, Programming]- 面向过程强调的过程: 这里的区别在于:1 是面向过程 2:是面向对象
例如:**1:打开冰箱,2:把大象放进去,3:关上冰箱**
例如:**1:自己买材料,2:肉,3:鱼香内丝调料,4:蒜苔,5:胡萝卜等等然后切菜切肉,6:开炒,7:盛到盘子里**
例如:**1:去饭店,2:张开嘴,3:老板,4:来份鱼香肉丝饭**- 面向对象强调结果:
1:例如: 饿了,去平台点餐,这个动作就是面向对象.你没有去市场买菜做饭.....只要有 app 就可以了.
2:例如: 衣服脏了,直接甩给女票去处理等着穿干净的就可以了,而然你没有关注中间的过程.只要找到对象就可以了2:面向过程的优缺点:
1: 面向对象有什么优势呢？首先你不需要知道鱼香肉丝是怎么做的，降低了耦合性。如果你突然不想吃鱼香肉丝了，想吃洛阳白菜，对于1你可能不太容易了，还需要重新买菜，买调料什么的。对于2，太容易了，大喊：老板！那个鱼香肉丝换成洛阳白菜吧，提高了可维护性。总的来说就是降低耦合，提高维护性.
2: 面向过程是具体化,流程化的,解决掉一个问题,你需要一步一步的分析,一步一步的实现.
3: 面向对象是模型化的,你只需抽象出一个类,这是一个封闭的盒子,在这里你拥有数据有解决问题的方法,需要什么功能直接使用就可以了,不必一步一步的实现,至于这个功能是如何实现的,管我们什么事,我们会用就可以了.4: 面向对象的底层其实还是面向过程:把面向过程抽象成类,然后封装,方法我们使用就是面向对象了
面向过程:
优点:性能比面向对象好,因为类调用时需要实例化,开销比较大,比较消耗资源
缺点:不易维护.不易复用.不易扩展优点:易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护.
缺点:性能比面向过程差.
3: 面向对象的三大特征:
- 1:封装性: 把相关的数据封装成一个"类"组件,隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
- 2:继承性: 是子类自动共享父类和方法,这是类之间的关系,提高代码复用性；继承是多态的前提。
- 3:多态: 增强软件的灵活性和重用性,父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。
4:对象和类
-------------------------------------------------------对象---------------------------------------------------------
每个对象具有三个特点:对象的状态,对象的行为和对象的标识:
1:对象的状态用来描述对象的基本特征.
2:对象的行为用来描述对象的功能.
3:对象的标识是指对象在内存中都有唯一的地址用来和其他对象分开来.
4:类是一类事物的抽象,对象是具体的实现现实世界中，随处可见的一种事物就是对象，对象是事物存在的实体，如人类、书桌、计算机、高楼大厦等。人类解决问题的方式总是将复杂的事物简单化，于是就会思考这些对象都是由哪些部分组成的。通常都会将对象划分为两个部分，即动态部分与静态部分。静态部分，顾名思义就是不能动的部分，这个部分被称为“属性”，任何对象都会具备其自身属性，如一个人，它包括高矮、胖瘦、性别、年龄等属性。然而具有这些属性的人会执行哪些动作也是一个值得探讨的部分，这个人可以哭泣、微笑、说话、行走，这些是这个人具备的行为（动态部分），人类通过探讨对象的属性和观察对象的行为了解对象。
5:类和对象的关系:
1:计算机语言用来描述现实世界事物的 属性和行为
2:那么怎么通过 Java 语言描述? 通过类来描述事物,把事物的属性当做成员变量,把行为当做成员方法.
分析手机事物:
属性: 颜色. 尺寸. 品牌. 价格…
方法: 打电话 发短信 听音乐…
类: 手机类. 抽取相同的属性和行为
对象: 可以按照模版生产很多个手机,比如 1 号手机对象,包含特有的成员比变量和成员方法
--------------------------------------------------------类-----------------------------------------------------------
- Java 语言最基本单位就是类,类似于类型
- 类是一类事物的抽象
- 可以理解为模版或者设计图纸
1: 类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。例如一个鸟类，鸟类封装了所有鸟的共同属性和应具有的行为，其结构如图所示：
练习: 类的创建使用
1:通过 class关键字创建类, 通过 new 关键字创建对象
public class Test1 {
public static void main(String[] args) {
//p是引用对象，持有了对于Person对象的地址值的引用
//此时的p，含有属性，但都是默认值
Person p = new Person();
//设置属性值
p.name="lisi";
p.age=20;
//调用方法
p.eat();
p.sleep();
}
}
class Person{
//属性--成员变量
String name;
int age;
//行为--方法
void eat(){
System.out.println("吃饭饭");
}
void sleep(){
System.out.println("睡觉觉");
}
}6: Java 的封装
-----------------------------------------------------封装----------------------------------------------------------
1: 在面向对象程序设计方法中,封装是指定一种将抽象性函式接口的实现细节部分包装,隐藏起来的方法. 封装可以被认为是一个保护屏障,防止该类的代码和数据 被外部类定义的代码随机访问. 要访问该类的代码和数据,必须通过严格的接口控制.
封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段
适当的封装可以让程式码更容易理解与维护,也加强了程式码德安全性.
封装的优点
- 1: 良好的封装能够减少耦合
- 2: 类内部的结构可以自己修改
- 3: 可以对成员变量进行更精确的控制
- 4: 隐藏信息,实现细节
练习:封装学生
private关键字
2: 是一个权限修饰符，用于修饰成员变量和成员函数，被私有化的成员只能在本类中访问。
想要修改只能，对外提供公共的，get和set方法。
public class Student {
//String name;
//把属性隐藏起来
private String name;
//提供公共的访问方法
//设置公共的赋值方法
public void setName(String n){
name=n;
}
//设置公共的取值方法
public String getName(){
return name;
}
int age;
}
class StDemo{
public static void main(String[] args) {
Student s = new Student();
//不能访问私有的
//s.name="zhangsan";
//System.out.println(s.name);s
//利用setXxx()给属性赋值
s.setName("zhangsan");
//利用getXxx()给属性取值
System.out.println(s.getName());
}
}1: 封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。例如，用户使用电脑，只需要使用手指敲击键盘就可以实现一些功能，用户无须知道电脑内部是如何工作的，即使用户可能碰巧知道电脑的工作原理，但在使用电脑时并不完全依赖于电脑工作原理这些细节。
7: Java 的继承
-------------------------------------------------------继承---------------------------------------------------------
概念:
- 继承是面向对象最显著的一个特征:
- 继承是从已有的类中派生出新的类,新的类吸收已有的数据属性和行为,并能扩展新的能力.
- Java 继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据获新的功能,也可以用父类的功能,但不能选择地继承父类/超类/基类
- 这种技术使得复用以前的代码非常容易,能够大大缩短开发周期,降低开发费用.
- 提高复用性,只要继承父类,就能有一样的功能
特点
- 使用 extends 关键字
- 相当于子类把父类的功能复制一份
- Java 只支持单继承
- 继承可以传递 (爷爷, 儿子, 孙子的关系)
- 不能继承父类的私有成员
- 继承多于功能的修改,子类可以拥有父类的功能的同时,进行功能拓展
- 像 is a 的关系
super关键字
- 通过 super 关键字可以使用父类的内容
- super 代表父类的一个引用对象
- 如果用,必须出现调用位置的第一行
方法的重写
- 继承后.子类就拥有了 父类的功能
- 那么在子类中,可以添加子类特有的功能也可以修改父类的原有功能
- 子类中方法签名与父类完成一样,(包括方法的返回值,方法名和参数值列表,完成一致),会发生一致时,会发生覆盖/复写操作,相当于修改功能
一定要注意的地方: - 父类中的私有方法不能被重写
- 子类重写父类方法时,修饰符要大于等于父类修饰符的权限
类的继承格式
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:
class 父类 {
}
class 子类 extends 父类 {
}class A extends c{ //原来的eat()拿走了 }
class B extends c{ //原来的eat()拿走了 }
class c{
public void eat(){
syso("eat");//打印输出
}
}那当我们的程序为什么需要继承那充分的说明我们继承的优点大大缩短我们的开发
开发动物类,其中动物分别为企鹅及老鼠,要求如下:
- 企鹅实现的功能: 属性 (姓名 name, id) , 方法 ( 吃eat , 睡, sleep)
企鹅类:
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}- 老鼠类实现的功能: 属性 ( 姓名 name , id), 方法 ( 吃 eat, 睡 sleep)
public class Mouse {
private String name;
private int id;
public Mouse(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是"+ id + "号" + name + ".");
}
}创建了两个相同的动物类:我们从中可以看出代码存在重复,并没有达到我们代码简化,那我可以利用继承把我们两段代码中相同的方法提取并组成一个父类
公共的父类通过子类继承父类:
public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}继承之后的代码
企鹅类: extends 关键字
public class Penguin extends Animal {
public Penguin(String myName, int myid) {
super(myName, myid);
}
}
老鼠类: extends 关键字
public class Mouse extends Animal {
public Mouse(String myName, int myid) {
super(myName, myid);
}
}继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
子类的创建可以增加新数据、新功能，可以继承父类全部的功能，但是不能选择性的继承父类的部分功能。继承是类与类之间的关系，不是对象与对象之间的关系。
8: Java 的多态的好处
-----------------------------------------------------多态-----------------------------------------------------------
概念: 重点: 多态是同一个行为具有多个不同表现形式或形态的能力.
- 多态只同一个实体同时具有多种形式,他是面向对象设计 (OOP) 的一个重要特征:
- 主要是指一个对象,在不同时刻,代表的对象不一样,指得是对象的多种形态.
- 好处是可以把不同的子类都当做父类,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,统一调用标准
- 例如: 水 在不同时刻可以有多种形态,包括水蒸气, 冰, 水 - Java 怎么体现多态呢? 狗有两种形态,狗和小动物
多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类以及相关类。该统一风格可以由父类来实现，根据父类统一风格的处理，就可以实例化子类的对象。由于整个事件的处理都只依赖于父类的方法，所以日后只要维护和调整父类的方法即可，这样降低了维护的难度，节省了时间。
在提到多态的同时，不得不提到抽象类和接口，因为多态的实现并不依赖具体类，而是依赖于抽象类和接口。
class Animal
class Dog extends Animal
Dog d = new Dog();//狗是狗
Animal a=new Dog();//狗是小动物，创建了狗的对象，赋值给动物对象，这就是多态多态的优点 | 多态存在的三个必要条件 |
1: 消除类型之间的耦合关系 | 继承 |
2: 可替代性 | 重写 |
3: 接口性 | 父类引用指向子类对象 |
4: 接口性 | |
5: 灵活性 | |
6: 简化性 |
案例 1:
Parent p = new Child();
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
以下是一个多态实例的演示，详细说明请看注释：
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
输出的结果为:
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠案例 2:
- 多态的前提是继承
- 要有方法的重写
- 父类引用指向子类读对象: 例如 : Animal a = new Dog(); – 大到小 ,向上转型
- 多态中,编译看左边,运行看右边
package cc;
public class p {
public static void main(String[] args) {
/*Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.kanjia();
d.eat();*/
//父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。
Animal an = new Dog();
an.eat();//只可以用父类的功能，这就统一了调用的标准
//狗吃肉,由于eat()发生了重写，所以父类方法被覆盖掉了
}
}
class Animal{
public void eat(){
System.out.println("大小通吃");
}
}
class Dog extends Animal{
public void kanjia(){
System.out.println("狗可以看家");
}
public void eat(){
System.out.println("狗吃肉");
}
}
