面向过程(POP) 与 面向对象(OOP)
二者都是一种思想，面向对象是相对于面向过程而言的。
面向过程，强调的 是功能行为，以函数为最小单位，考虑怎么做。
面向对象，将功能封装进对 象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如 抽象、分类、继承、聚合、多态等。
面向对象的三大特征
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)
英文全称
面向对象：Object Oriented Programming
面向过程：Procedure Oriented Programming
类(Class)和对象(Object)是面向对象的核心概念。
类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
“万事万物皆对象”
可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人 。
属 性：对应类中的成员变量
行 为：对应类中的成员方法
Field = 属性 = 成员变量，Method = (成员)方法 = 函数
类的语法格式
修饰符 class 类名 {
属性声明;
方法声明;
}
说明：修饰符public：类可以被任意访问
类的正文要用{ }括起来
举例：
public class Person{
private int age ; //声明私有变量 age
public void showAge(int i) { //声明方法showAge( )
age = i;
} }
创建对象语法：
其实应该有好几种 但是 目前学的进度不允许我一一列举 。。。。。
类名 对象名 = new 类名();
创建一个类
//1.创建类，设计类的成员
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat(){
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人可以睡觉");
}
public void talk(String language){
System.out.println("人可以说话,使用的是：" + language);
}
类的访问机制：
在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。
（例外：static方法访问非static，编译不通过。）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中
定义的成员。
我们也可以不定义对象的句柄，而直接调用这个对象的方法。
这 样的对象叫做匿名对象。
如：new Person().shout();
**使用情况 **
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。
类的成员之一：属性
语法格式： 修饰符 数据类型 属性名 = 初始化值 ;
修饰符 常用的权限修饰符有：private、缺省、protected、public
******************其他修饰符：static、final (暂不考虑)
数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
属性名
属于标识符，符合命名规则和规范即可。
举例：
public class Person{
private int age; //声明private变量
age public String name = “Lila”; //声明public变量 name
}
变量的分类：成员变量与局部变量。
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
成员变量（属性）和局部变量的区别
类的成员之二
方法(method)
什么是方法(method、函数):
方法是类或对象行为特征的抽象，用来完成某个功能操作。
在某些语言中 也称为函数或过程。
将功能封装为方法的目的是，可以实现代码重用，简化代码
Java里的方法不能独立存在，所有的方法必须定义在类里。
方法的声明格式：
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝
其中： 修饰符：public,缺省,private, protected等
返回值类型：
没有返回值：void。
有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。
举例：
public class Person{
private int age;
public int getAge() { //声明方法getAge()
return age; }
public void setAge(int i) { //声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
} }
方法的调用
方法通过方法名被调用，且只有被调用才会执行。
注 意：
方法被调用一次，就会执行一次
没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可
以不必使用return语句。如果使用，仅用来结束方法。
定义方法时，方法的结果应该返回给调用者，交由调用者处理。
方法中只能调用方法或属性，不可以在方法内部定义方法。
堆（Heap），此内存区域的唯一目的 就是存放对象实例，几乎所有的对象 实例都在这里分配内存。这一点在 Java虚拟机规范中的描述是：所有的 对象实例以及数组都要在堆上分配。
通常所说的栈（Stack），是指虚拟机 栈。虚拟机栈用于存储局部变量等。 局部变量表存放了编译期可知长度的 各种基本数据类型（boolean、byte、 char 、 short 、 int 、 float 、 long 、 double）、对象引用（reference类型， 它不等同于对象本身，是对象在堆内 存的首地址）。 方法执行完，自动释 放。
方法区（Method Area），用于存储已 被虚拟机加载的类信息、常量、静态 变量、即时编译器编译后的代码等数 据。
匿名对象
/*
* 一、理解“万事万物皆对象”
* 1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
* >Scanner,String等
* >文件：File
* >网络资源：URL
* 2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
*
* 二、内存解析的说明
* 1.引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）
*
* 三、匿名对象的使用
* 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
* 2.特征：匿名对象只能调用一次。
* 3.使用：如下
*
*/
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone();
// p = null;
System.out.println(p);
p.sendEmail();
p.playGame();
//匿名对象
// new Phone().sendEmail();
// new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
//**********************************
PhoneMall mall = new PhoneMall();
// mall.show(p);
//匿名对象的使用
mall.show(new Phone());
}
}
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
class Phone{
double price;//价格
public void sendEmail(){
System.out.println("发送邮件");
}
public void playGame(){
System.out.println("玩游戏");
}
public void showPrice(){
System.out.println("手机价格为：" + price);
}
}
方法的重载(overload)
重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数 类型不同即可。 。
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类 型)。调用时，根据方法参数列表的不同来区别。
重载示例：
//返回两个整数的和 int add(int x,int y){return x+y;}
//返回三个整数的和 int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和 double add(double x,double y){return x+y;}
"两同一不同":同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
参数名无所谓 关键看形参列表类型
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
//如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}
//如下的3个方法不能与上述4个方法构成重载
// public int getSum(int i,int j){
// return 0;
// }
// public void getSum(int m,int n){
//
// }
// private void getSum(int i,int j){
//
// }
. 在通过对象调用方法时，如何确定某一个指定的方法：
-
方法名 ---> 参数列表
**可变个数形参的方法
*
- 1.jdk 5.0新增的内容
- 2.具体使用：
- 2.1 可变个数形参的格式：数据类型 … 变量名
- 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
- 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
- 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
例子如下
* public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
//
// }
- 2.5 可变个数形参在方法的形参中，必须声明在末尾
- 就是
* // public void show(String ...strs,int i){
//
// }
其中的String…strs必须放在int i 后面 上面放反了
- 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。**
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
// test.show("hello");
// test.show("hello","world");
// test.show();
test.show(new String[]{"AA","BB","CC"});
}
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
方法参数的值传递机制
关于变量的赋值：
*
- 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
- 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
- 方法的形参的传递机制：值传递
- 1.形参：方法定义时，声明的小括号内的参数
- 实参：方法调用时，实际传递给形参的数据
- 2.值传递机制：
- 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
- 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
图中12这个实参 赋值给了形参i
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
//交换m和n的值
// int temp = data.m;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执 行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死 循环。
面向对象特征之一：封装和隐藏
为什么需要封装？封装的作用和含义？
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内 部的结构吗？有必要碰电动机吗？
我要开车，…
我们程序设计追求“高内聚，低耦合”。
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅对外暴露少量的方法用于使用。
------–—
隐藏对象内部的复杂性，只对外公开简单的接口。
便于外界调用，从而提 高系统的可扩展性、可维护性。
通俗的说，把该隐藏的隐藏起来，该暴露 的暴露出来。这就是封装性的设计思想。
信息的封装和隐藏
Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑， 限制对属性的不合理操作；
便于修改，增强代码的可维护性；
----------******----
构造器
构造器的特征
它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值
构造器的作用：
创建对象；给对象进行初始化
如：Order o = new Order()
Person p = new Person(“Peter”,15);
如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的 构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自 动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们 要“洗澡”了。
构造器(构造方法)
语法格式： 修饰符 类名 (参数列表) { 初始化语句； }
举 例：
创建Animal类的实例：Animal a = new Animal(); 调用构造器，将legs初始化为4。
public class Animal {
private int legs; // 构造器
public Animal() {
legs = 4;
}
public void setLegs(int i) {
legs = i； }
public int getLegs() {
return legs;
} }
一、构造器的作用：
- 1.创建对象
- 2.初始化对象的信息
- 二、说明：
- 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
public class PersonTest {
public static void main(String[] args) {
//创建类的对象:new + 构造器
Person p = new Person();
p.eat();
Person p1 = new Person("Tom");
System.out.println(p1.name);
}
}
class Person{
//属性
String name;
int age;
//构造器
public Person(){
System.out.println("Person().....");
}
上面的就是个默认空参构造器
public Person(String n){
name = n;
}
//
public Person(String n,int a){
name = n;
age = a;
}
//方法
public void eat(){
System.out.println("人吃饭");
}
public void study(){
System.out.println("人可以学习");
}
}
- 2.定义构造器的格式：权限修饰符 类名(形参列表){}
下面就是个构造器定义了形参String n,int a
```java
public Person(String n,int a){
name = n;
age = a;
``
- 3.一个类中定义的多个构造器，彼此构成重载
- 看代码 那么多的person（）
- 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
- 5.一个类中，至少会有一个构造器。
关于赋值 值传递
属性赋值的先后顺序 - ① 默认初始化
- ② 显式初始化
- ③ 构造器中初始化
- ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
- 以上操作的先后顺序：① - ② - ③ - ④
JavaBean
JavaBean是一种Java语言写成的可重用组件。
所谓javaBean，是指符合如下标准的Java类：
类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关 心任何改变。
通俗举例：
假如数据库中有一个表 要将表展示给用户 通过Java的一个类调用 这个类就算是JavaBean。
uml类图
this关键字
在Java中，this关键字比较难理解，它的作用和其词义很接近。
它在方法内部使用，即这个方法所属对象的引用；
它在构造器内部使用，表示该构造器正在初始化的对象。
this 可以调用类的属性、方法和构造器
什么时候使用this关键字呢？
当在方法内需要用到调用该方法的对象时，就用this。
具体的：我们可以用this来区分属性和局部变量。
比如：this.name = name;
***************+
形参和属性同名了
不同名也可加 但同名就必须加
class Person{
private String name;
private int age;
public Person(){
// this.eat();
String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
System.out.println(info);
}
public Person(String name){
this();
this.name = name;
}
其中 this.name 的name是属性（即 private String name中的name）
后面等于的name是形参（即public Person(String name)中的name）
注意：
可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其 他的构造器！
例子如下 直接this后面括号写想调用的构造器的形参 如图红线
明确：
1.构造器中不能通过"this(形参列表)“的方式调用自身构造器
2.如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 “this(形参列表)”
3."this(形参列表)"必须声明在类的构造器的首行！
4.在类的一个构造器中，最多只能声明一个"this(形参列表)”（与上一条呼应 第一行只有一个）
MVC设计模式
MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与 数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式 使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程 序的耦合性。
模型层 model 主要处理数据 M
数据对象封装 model.bean/domain
数据库操作类 model.dao
数据库 model.db
视图层 view 显示数据 V
相关工具类 view.utils
自定义view view.ui
控制层 controller 处理业务逻辑 C
应用界面相关 controller.activity
存放fragment controller.fragment >
显示列表的适配器 controller.adapter
服务相关的 controller.service >
抽取的基类 controller.base
JDK中主要的包介绍
- java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能
- java.net----包含执行与网络相关的操作的类和接口。
- java.io ----包含能提供多种输入/输出功能的类。
- java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日 期日历相关的函数。
- java.text----包含了一些java格式化相关的类
- java.sql----包含了java进行JDBC数据库编程的相关类/接口 7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这 些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S
4985
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
