1.面向过程和面向对象
面向过程和面向对象都是程序设计的一种风格(思想)
面向对象的程序设计
面向过程:
是以函数(一个一个的功能)为结构进行代码组织,
解决问题时,分析实现所需的步骤,然后一步一步实现即可
代表语言: C语言.
相对于面向对象语言,扩展能力差、后期维护难度较大
面向对象:（ Object Oriented Programming），简称OOP
是以类为单位进行组织, 类: 一类问题/分类 String,Math,Arrays,Scanner
public class 人类{
定义人有什么属性(变量)
人有什么功能(方法)
}
典型代表语言:C++,C#,java,python.......
动物类{
动物共有属性和功能(代码复用)
}
猫 继承 动物{
定义自己特有的属性和功能 (扩展自己的功能)
}
狗 继承 动物{
定义自己特有的属性和功能
}
是一种设计设计者思想,适合解决复杂的问题,扩展性,维护性更好
举例
开车动作简单,面向过程的思想就可以解决
造车就比较复杂了,适合使用面向对象思想,要进行分类(轮胎,玻璃,发送机)
面向过程适合简单的问题
面向对象适合复杂问题,先宏观的分类设计,具体某一个步骤落地时,
又需要面向过程,他们是相辅相成的.
面向过程关心怎么解决问题,步骤有哪些...
面向对象关心谁来解决问题(类String,Arrays...冰箱类,人类)
2.类和对象
类: 具有相同特征的事物的抽象描述(定义)
同一类事物的抽象描述(定义) 概念,模板
对象:该类事物具体存在的一个个个体,是真实存在,也称为实例
万事万物(大千世界中具体存在的东西),皆为对象.
人类-->一类群体 概念
张三-->具体的人,对象
电脑-->一类电脑
我的电脑--->可以使用的,具体,对象
编程是对现实生活事物的体现,根据现实事物进行抽象(定义).
先设计类(定义某一类事物的功能)
类中可以定义:
变量 属性 名词
方法 行为 动词
构造方法
块 没有名字的一个代码块
内部类 在类的内部定义类(嵌套)
对象: 是以类为模板,在内存中创建出来的具体实例
分类,某一类
类--把具有相同属性行为的同一类事物进行抽象,定义.
对象-- 类的实例, 根据类这个模板(概念,定义...),在内存中创建一个实例(内存空间)
Car car = new Car();
3.java中的变量
按位类型分:
基本类型
引用类型
按位置分:
成员变量(全局): 系统会在默认的无参构造方法中进行初始化
局部变量
4.构造方法
作用: 用来为新创建出来的对象的成员变量进行初始化.
定义: 方法名与类名相同,没有返回值,不需要void修饰
特点: 每一个类默认有一个无参的,还可以创建多个有参的构造方法,一旦创建了有参的构造方法,默认无参的会消失,
如果需要,就显示定义无参构造方法
5.在一个类中,有多个名称相同的方法---方法重载
如何区分多个同名方法:
方法参数: 个数,数据类型,顺序
6.对象与引用
Car car = new Car();
car 最终持有的是对象在堆内存空间的地址,持有的不是对象本身
7.this关键字
this关键字表示当前正在执行的对象
Student s1 = new Student(10,"张三");
Student s2 = new Student(11,"李四")
s1.study();
s2.study();
public Student(int number,String name){
this.number = number; 使用this关键字对成员变量进行访问
this.name = name;
}
public void study(){
System.out.println(this.name+"好好学习");
this.exam();
}
public void exam(){
System.out.println(this.name+"认真考试");
}
8.static 关键字
static表示静态,可以修饰成员变量,成员方法,代码块,内部类
类--class--静态代码 只有一份的存在
静态--在内存中只有一份的存在
public class Chinese{
String name;
static String country = "中国";
}
new Chinese();
name = null;
// country = "中国";
new Chinese();
name = null;
// country = "中国";
static修饰后的成员,随着类的加载而加载
先于对象而存在
static修饰的成员变量在内存中只有一份,适合将所有实例都相同的属性设计为静态(中国人类 国籍都是中国)
静态的成员可以使用类名/对象名调用,一般建议使用类名访问
static修饰方法
静态方法只能访问静态的变量,不能访问非静态的变量.
在方法中不使用非静态成员变量时,可以将方法设计为静态
public static int max(int a, int b) {
return (a>=b)?a:b;
}
9.
类中可以定义:
成员变量 (非静态成员变量属于对象,每个对象中都有一份, 静态的成员变量属于类,和类一样只有一份).
成员方法(非静态的成员方法,属于对象,可以使用非静态的成员变量和静态成员变量,
静态的成员方法,只能使用静态的成员变量)
构造方法 在创建对象后,为对象成员变量进行初始化,有无参,也可以有有参的
代码块:
定义在类中, 类似于一个没有名字的方法,
分为实例代码块
静态代码块
因为代码块,没有名字,只能在,满足条件时,自动由系统调用
{
}
static{
}
实例代码块: 在创建对象时,被自动调用执行
静态代码块: 在类被加载时,被自动调用执行
类什么时候被加载:
通过类名访问类中静态成员时,类会被加载
在一个类中使用main方法,也会加载类
创建对象也会加载类
类只被加载一次
如果有多个实例代码块或多个静态代码块,他们会按照先后顺序执行
实例代码块 先于构造方法执行.
10.
问题: 项目越写类越多, 难免可能会出现同名的类(java.util.Date, java.sql.Date)
不同类功能不同,需要分类管理
包:
为了解决一些类管理的问题, java引入包机制来解决
包称为类的命名空间(可以理解为是一个文件夹)
是类名的组成部分
类名(全类名) = 包名(地址) + 类名简称
day1.demo2.Car
作用:
一个类属于不同的包,就可以避免同名类问题.
按照不同的功能管理类(web层, service逻辑处理,dao数据访问层)
控制访问权限
包名单词全部小写
包命名:
第一级,项目类型 com,org,gov,edu.....
第二级,公司名称 oracle sun huawei ali ffyc
第三级,项目名称 oa erp cms
第四级,功能模块名称
在类中,使用其他包中的类时,需要使用import关键字导入类的地址(全类名)
java.lang包中的类不需要导入.
11.访问权限修饰符
访问权限修饰符,用来修饰类中的成员,控制是否可以被访问.
从大到小
public: 公共权限,在系统中哪里都可以访问
修饰类(包含内部类),方法(构造方法,成员方法),成员变量
protected:受保护权限,在本类,同包类,不同包子类中可以访问
修饰内部类,方法(构造方法,成员方法),成员变量
: 默认权限 在本类,同包类访问
修饰类(包含内部类),方法(构造方法,成员方法),成员变量
private: 私有权限 只能在本类中使用
修饰内部类,方法(构造方法,成员方法),成员变量
12.面向对象语言的三大特征:
封装:
封装含义:
1.包装,例如我们将一些常用的功能进行抽取,定义成一个方法
2.面向对象特征中的封装: 隐藏,对类中的成员对外是否可见进行控制
使用权限修饰符控制成员对外的可见性
封装案例1: 将类中属性私有化
封装案例2: 将某些方法私有化
java设计模式(模板,固定套路)
解决一类问题的固定方式.
单例模式: 单个实例,在系统中,想让某个类只能创建一个对象
成员变量和局部变量
位置:
成员变量：在类中定义 局部变量：在方法中定义或者方法的参数
权限修饰不同
成员变量：可以使用权限修饰符(static)
局部变量：不可以使用权限修饰符
初始化不同:
成员变量: 非静态--在创建对象后,由构造方法初始化
静态--类加载时初始化
局部变量: 声明后后,使用前必须自己进行初始化
生命周期不同:(什么时候生(创建),什么时候死(销毁))
成员变量: 生(创建) 销毁
非静态--创建对象 对象被垃圾回收
静态--类加载时 类被卸载
局部变量:
生 销毁
当方法被调用 当方法执行结束
在内存中的位置不同:
成员变量: 非静态--与对象在堆空间存储
静态--与类信息在方法区中存储
局部变量: 与方法在栈空间中存储
13.继承
子继承父 儿子就可以拥有父亲的功能
面向对象语言也引入了继承的思想
猫和狗 都用有名字,年龄,吃东西的属性和行为.
可以将这些共性的属性和行为进行抽取,这样就不需要在每个类中定义同样属性和行为,
只需要类与类之间建立继承关系即可.
猫和狗 都是动物,他们都有名字,年龄,吃东西
抽取一个动物类
名字,年龄,吃东西
猫类 继承 动物类
猫抓老鼠
狗类 继承 动物类
看家
继承优点:
减少代码冗余,提高代码的复用性
提高程序功能的扩展性(分别在猫和狗类中维护他们各自特有的属性和行为)
什么时候使用继承?
猫是动物
狗是动物 满足什么是什么 is-a
小汽车
公交车
大巴车 Car
卡车
方法重写:
当子类中的方法实现与父类中方法实现不同时,
在子类中对父类中某个方法结构重新定义,重写实现.
重写时要求方法结构与父类方法结构相同
super
在子类中使用super关键字,访问父类中定义的那部分成员.
super.成员变量
super.成员方法(常用) 当子类中重写了父类方法时,
为了区分调用的是父类中还是子类中重写的方法,使用super调用父类中的.
super() 表示调用父类中构造方法
继承中的构造方法的调用:
总是在子类的构造方法中,会去使用super()调用父类的构造方法.
为了确保对父类成员进行初始化.
14.抽象类,抽象方法
抽象方法: 只有方法声明(定义 public void test()),没有具体的实现
Animal
eat(){
动物吃东西
}
动物类型很大,在类体系结构位于上层,里面实现与大多数子类实现都可能不一样.
在上层类中实现功能,就没有必要了,但是程序设计时,应该在上层定义这一类型应该有什么功能.
然后让子类继承父类,在子类中对抽象方法进行重写.
15.多态
多种状态
扫一扫
1208
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
