Java-面向对象(基础知识)

面向过程的设计思想
面向对象的设计思想
对象和类的关系
java类的定义
构造函数(构造方法)
对象的创建和使用
this 关键字
static 关键字
package 和 import 关键字
权限修饰符(访问控制)
类的继承
方法的重写
final 关键字
对象转型
多态
抽象类
接口

- - -- -  - - - - - - - - - - -  - --  -- -  --  - --   --  --  - --   -- - --    --
面向对象:
    1, 面向过程的思想
        准备去一个地方:
            先买车, 挂牌, 开导航, 踩油门, 过黄河, 穿越珠穆朗玛峰...

    2, 面向对象的思想
        我开着车去, 车怎么去随便
        所有去这个地方的信息, 全部封装在这个车里面, 我不了解这个车是怎么运行的, 我也不需要了解, 我只知道我能到达这个地方就行了

        面向对象的基本思想是, 从现实世界中客观存在的事物出发, 来构造软件系统, 并在系统的构造中尽可能的运用人类的自然思维方式, 面向对象是目前人与计算机沟通最简单的语言思想

        合适的方法出现在合适的类里面

    3, 什么是类, 什么是对象?

        对象是类的一种实例化, 对象用"属性"和"方法"来对应描述事物所具有的"静态属性"和"动态属性"
        类是用于描述同一类形的对象的一个抽象的概念, 类中定义了这一类对象应该具有的"静态属性"和"动态属性"

        类可以看成是一类对象的模板, 对象可以看成该类的一个具体实例.

举个栗子(什么是瓶子-->一类事物的抽象-->静态属性,动态属性)
什么是类?    学生是类, 瓶子是类, 老师是类
举个栗子(人-->学生-->张三)
什么是对象?  这个学生是对象, 这个瓶子是对象, 这个老师是对象, 符合这类事物的特征的某一个东西, 叫对象

        领导-->显示职工的姓名
        职工:合适的方法出现在合适的类里(有图有真相)
            静态属性:
                姓名: 张三
                年龄: 24
                工资: 3000
            动态属性:
                显示姓名
                显示年龄
                修改姓名
                领取工资

4, 类与类之间的关系

　　1.关联关系(最弱的一种关系)(有图有真相):

不好下一个定义, (A类中某个方法的参数是B类的某一个对象)

举个栗子(学生<--学校-->老师)

老师要讲课, 这是一个方法, 要传个参数进去, 参数是学生对象

　　2.继承关系(避免多重继承)(有图有真相) extends

什么是一种什么

举个栗子(运动员-->球类运动员-->篮球运动员)

　　3.聚合关系(聚集, 组合)(有图有真相)

什么是什么的一部分

举个栗子(球队-->(王队长, 队员))

组合----人: 头, 身体

聚集:构成这个类的这部分可以是这个类的, 也可以是另外一个类的,

组合:每一部分只属于一个类

　　4.实现关系(有图有真相) implements

接口:只管定义方法, 怎么实现由子类去做

举个栗子(接口(开车的方法), A类可以实现, B类也可以实现)

5, java类的定义, 对象和引用
        定义一个类:
            public class 类名{
                成员变量
                成员方法
            }
引用这个类:
        //在main中的实例化(引用)
类名 变量名 = new 类名();
变量名.成员变量/成员方法
//可以 点 出里面的成员变量和成员方法

        java: 万物皆对象, 处处皆需求
对象是对属性(成员变量, 静态属性)和方法(函数, 动态属性)的封装
包括:java中提供的类(math/random), 程序员自己定义的类

        为什么要使用面向对象的思想:
            面向对象更容易达到一种境界:
                Reusable(重用性), Extensibility(可扩展性)
//本意是继承和扩展的意思,有些地方是派生的含义
            面向组件(Component)--比对象更高层次的抽象
                WebService

    6,    成员变量的初始化(有图有真相)
            整数型--0
            浮点型--0.0F/D
            boolean--false
            char--‘/u0000‘
            String--null
        成员变量可以是java中任意一种数据类型(基础数据类型和引用类型)
            什么是引用类型 ? 就是那些类,作为类的,也就是指那些对象,
还包括数组(都是对象), 接口
            成员变量可以是接口(接口是引用类型,当它未指向任何一个引用的子类时),初始化值为                null
            null--是对象,表示什么都不指向.
        成员变量可以初始化, 也可以不初始化(java默认初始化)
成员变量和局部变量的区别:
         成员变量的作用范围-->整个类
         类和对象的关系
            C c1 = new C();   // C是类, c1 c2是对象, C();是方法.
            C c2 = new C(); // c1, c2在这里是局部变量

7, 构造函数(构造方法)

在使用 new 来创建一个对象的时候就是调用的这个类的一个构造方法(构造函数),

构造方法名与类名同名, 并且没有返回值(没有返回值也不要写void)

区分空参的构造函数和有参数的构造函数

//如果什么也不写,程序默认是有一个空参的构造方法的.

//如果写了一个有参数的构造方法,就会自动覆盖空参的构造方法,所以也要再写一个空参的构造方法

注释, 命名规则!!!!!!!!!!

//变量名如果定义的很随意,代码量很多就会忘记写的是什么了.所以要写好名

//   不要这样  String aa = "";

继承中的构造函数:

--子类的构造方法必须调用父类的构造方法(不管调用哪一个)

--super(), 调用父类的构造方法, this()表示当前对象的引用,调用本类中另外的构造方法

8, 关键字this, static, package和import语句

this:(this表示当前对象的引用)

--在类的方法定义中使用this关键字代表使用该方法的对象的引用

//即,在同一个类中,用this.可以调用另一个方法

--当必须指出当前使用方法的对象是谁时要使用this

--有时this可以处理方法中成员变量和参数重名的情况

--this可以看作是一个变量, 它的值是当前对象的引用

static(不在堆里面也不在栈里面, 在数据区(data seg)):

--类名直接 . 出来的变量是静态变量, 每个类里面的静态变量只有一份,

是公用的(赋值后每个实例化的类都可使用)

--静态方法中不可访问非静态成员

--静态变量和静态方法不需要实例化

--计数

--单例模式

package:

--便于管理大型软件系统中数目众多的类, 解决类名重名的现象

--生成.jar文件 jar -cvf test.jar 路径/*.*(或者使用eclipse中的Export选项)

9, 访问控制, 权限修饰符( private (什么也不写) protected public)(有图有真相)
        puclic class 类名 {
            private 类型 属性1;
            private 类型 属性2;

            set, get方法(eg.
public String getName() {
        return name;
        }
        public void setName(String name) {
        this.name = name;
        }   )
        }

10, 面向对象的三大特性: 封装, 继承, 多态

封装(...)

封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类（对象）的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类（对象）以外的部分不能随意存取类（对象）的内部数据（属性），保证了程序和数据不受外部干扰且不被误用。

继承:

子类拥有父类的属性和方法(构造方法除外)

是实现代码复用的重要手段。Java的继承具有单继承的特点，即只能继承自一个父类，每个子类只有一个直接父类，但是其父类又可以继承于另一个类，从而实现了子类可以间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。

多态((执行期间)动态绑定, 或者叫池绑定)(有图有真相):

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

//也就是可以调用父类的同一个方法可以实现不同的结果

实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态的作用：消除类型之间的耦合关系。

重载(overload):

//是发生在同一个类里面的,对同一个方法进行不同的体现的关系

方法名相同, 只有参数类型不同或参数个数不同.返回值不同是不能构成重载的

重写(overwrite / override):

将父类的方法重新定义

--在子类中可以根据需要,从父类中继承来的方法进行重写

--重写方法必须和被重写的方法具有相同的方法名, 参数列表和返回类型

--重写方法不能使用比被重写方法更严格的访问权限

toString方法的重写 alt+shif+s (选toString()这个)

equals方法的重写    (选 hashcode() and equals这个)

11,super, final关键字

super: 指向父类的引用

final的变量值不能改变

 final的方法不能被重写

 final的类不能被继承

12, 对象转型(casting)

--父类的引用可以指向其子类的对象(使得代码的统一性提高, 便于扩展)

--父类的引用不可以访问其子类对象新增的成员(包括属性和方法), 如果硬要访问-->强转

--可以使用instanceof关键字来判断一下这个变量是不是这个类或者是这类的子类

13, 抽象类(方法)---类的扩展

--使用abstract关键字修饰的类(方法)

--含有抽象方法的类必须被声明为抽象类

--抽象类不能被实例化

--抽象方法只需要声明, 不需要被实现

14, 接口(一种特殊的抽象类, 所有的方法是一个抽象方法)---类需要实现的功能
        --语法定义:
            public interface InterfaceTest{

            }
        -- 一个类去实现一个接口, 使用implements关键字:
            public class test implements InterfaceTest{

            }
        --多个无关的类可以实现同一个接口
        --一个类可以实现多个无关的接口(注意避免接口方法重名的现象)
        --与继承关系类似, 接口与实现类之间存在多态性
        --接口中的属性默认为 public static final 也只能是public static final的
        --接口中只能定义没有实现的方法, 默认为 public, 也只能是 public, 接口可以继承其他的接口并添加新的属性和方法(没有实现的)
        --从JDK1.8以后接口开始可以有实现的方法, 使用default关键字修饰

--end--