1、面向对象编程

面向过程：关注的是步骤中的因果关系，一个因果关系断链整个程序废掉（蛋炒饭）

步骤和步骤之间因为因果关系构成模块，模块和模块之间因为因果关系构成系统。一个因果关系断链整个程序废掉
优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本低

缺点：难以解决非常复杂的业务逻辑，另外面向过程的方式导致软件之间的耦合度非常高，只要其中一环出现问题，整个系统会受到影响导致软件的扩展力差另外由于没有独立个体的概念，所以无法达到组件的复用

2、面向对象编程

面向对象：关注的是独立的个体，这个个体能为我做什么
一个抽烟的场景你可能会想到：一个抽烟的人，一个打火机，一包烟，抽烟的地方。这几个对象放在一起就构成了这个抽烟的场景。
也可以给对象进行扩展，每一个对象都是独立的，关注是对象的功能
优点：耦合度低扩展力强。更容易解决现实业务中更复杂的业务逻辑。组件复用性强
缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计

2.1面向对象编程特征

耦合度：关联强度

低耦合高扩展力面向对象能够实现
面向对象的三大特征
封装
继承
多态
所有面向对象的编程语言都有这三大特征

采用面向对象的方式开发一个软件，生命周期当中(整个生命周期当中贯穿使用OO面向对象方式）

面向对象的分析OOA
面向对象的设计OOD
面向对象的编程OOP

3、类和对象的概念

java程序员是虚拟和现实之间的桥梁
对象是存在的，共同特征称为类

什么是类？
类在现实世界中是不存在的，是一个模板，是一个概念，是人类大脑思考抽象的结果
类代表一类事物
在现实世界中对象a和对象b之间具有共同的特征，进行抽象总结出一个模板，这个模板称为称为类

什么是对象？
对象是实际存在的个体，现实世界当中实际存在

描述一下整个程序开发的过程：
*程序员先观察现实世界，从现实世界中寻找对象
*寻找n个对象后，所以的对象都有一个共同的特征
*程序员在大脑中形成一个模板（类）
*java程序员可以通过java代码来表示一个类
*java程序中有了类的定义
*然后通过类就可以创建对象
*有了对象之后，可以让对象直接协作起来形成一个系统

*类————[实例化]——对象
*对象又被称为实例
*对象————【抽象】——类

*重点：
类描述的是对象的共同特征
共同特征例如：身高特征
这个身高特征在访问的时候，必须先创建对象，通过对象去访问这个特征
特征具体到某个类上之后，值不同。有的对象身高1.8，有的对象身高1.6
一个类主要描述的是什么信息：特征+动作
特征信息：名字，身高，性别，年龄..
动作信息：吃，唱歌，跳舞，学习

3.1类的定义

类{
    属性：//描述对象的特征信息
    方法：//描述对象的动作信息
}
类的定义，从这里开始写代码

语法结构：
【修饰符列表】class 类名 {
    属性：
    方法：
}

学生类：描述所有学生对象的共同特征
       学生对象有哪些状态信息：
             学号【int】
             名字【String】
             性别【性别是一个属性，是一个数据，是数据就应该有数据类型】
             ...
        学生对象有哪些动作信息：
              吃饭
              睡觉
              学习
              玩
              唱歌
public class Student {
        //Student是一个类，代表了所有的学生对象，是一个学生模板
        //属性描述的是对象的状态信息，通常采用变量的方式定义
        //学号 
         int oo;

        // 姓名
       String name;
        //年龄
         int  age;
     //方法描述的是对象的状态信息

//当前例子只描述属性，不描述方法

3.11属性

属性通常采用一个变量的形式来完成
int oo;
int age;
String name;
String address;
java语言中包含两种类型：
基本数据类型
boolean
char
byte
short
int
long 
float
double        
引用数据类型
String.class   sun公司提供
student.class sun公司提供
User.class    程序员自己编写
product.class 程序员自己编写
Customter.class 程序员自己编写
......

3.12方法

//以下这个程序不使用方法，分析程序存在那些缺点
 public class MethodTest
 {
	 public static void main (String [] args) {
		  //编写10+20=30
		  int a=10;
		  int b=20;
		  int c=a+b;
		  System.out.println(a+"+"+b+"="+c);
		  //编写888+66的和
		  int x=888;
		  int y=666;
		  int z=x+y;
		  System.out.println(x+"+"+y+"="+z);
	 }
 }
    //以上这个需求为一个需求，计算两个int类型的和，功能相同，只不过每次参与的数据不同
	//缺点：代码没有得到重复的利用
	//改善：某个功能代码只写一遍，只给这个功能传入具体的数据，提高代码重复性
	public class MethodTest02
	{
		public static void main (String [] args){
			MethodTest02.sumInt(10,20);
            MethodTest02.sumInt(888,666);
		}
		public static void sunInt(int a,int b){
			int c=a+b;
			System.out.println(a+"+"+b+"="+c);
		}
	}

/*方法的本质是什么？
   1.方法是一段代码片段，并且这个代码片段可以完成某个特定的功能，并且可以重复利用
   2.方法定义在类体当中，在一个类体当中可以定义多个方法，方法的编写顺序没有先后
   3.方法体中不能定义方法
   4.方法体由java语句组成，遵守自上而下运行
   5.方法怎么样定义：【修饰符列表】返回值类型方法名（形式参数列表）{}
   【修饰符列表】可有可无
   返回值类型：一个方法完成某个特定的功能后，大多数需要返回值最终执行结果，执行结果可能是一个具体的数据，这个就是返回值
   怎么写？
   return 值；
   返回值数据类型和方法的数据类型一致，返回值类型是void的时候不能书写返回值
   方法名：首字母小写，见名知意，符合标识符规范
   形参：局部变量。int a,double b,String s。形参中起决定作用的的数据类型，形参的名字就是局部变量的名字
   方法在调用的时候，实际给这个方法传递的真实数据称为：实际参数，简称实参
   实参与形参
   1.数量相同
   2.类型对应相同
   6.方法怎么调用？
   方法只是定义而不调用是不会执行的，只有在调用的时候才会执行
   静态方法：类名.方法名（实参）
   实例方法：引用.方法名（实参）
   */

//方法执行得时候内存在哪里分配？执行代码片段在哪里？
//方法代码片段属于.class字节码文件的一部分。字节码文件在类加载的时候将其放进了方法区当中，所以JVM三块内存中方法区内存最先有数据
//存放的代码片段虽然在方法区内中只有一份，但可以重复调用
//每次调用的时候，需要给方法分配独立的活动空间，在栈内存中分配方法所运行的所属内存空间
//方法在调用的瞬间会给方法分配独立的内存空间，方法只定义不调用不会给该方法分配所属的内存空间
//在栈内存中分配，此时发生压栈动作，方法执行结束后，会给方法分配的内存空间全部释放，此时发生弹栈动作
//压栈：分配内存。弹栈：释放内存
//局部变量在方法体中声明，局部变量运行阶段内存在栈中分配
/*

	public class MethodTest06
	{
		public static void main(String [] args){
			MethodTest06.m();
			m();//省略类名，默认从当前类中找方法，若在当前类中找方法找不到则不能省略
		}
		public static void m(){
			System.out.println("HelloWorld");
		}
	}
	//定义一个方法该方法可以计算两个int类型数据的商，要求最终结果返回给调用者
	public class MethodTest08
	{
		public static void main(String [] args) {
            //调用方法，这里没有接收这个方法的返回值，采用变量方式接收
		    divde(10,3);	
            
			//变量的类型要求和返回值的数据类型相同（自动类型转换也可以）
			int a=dvide(10,3);//在调用方法的时候主方法暂停，进入调用的方法中去，待完成该方法后
再去执行主方法内容

			System.out.println(a);//这样写也行System.out.println(divde(10,3));
		}
		public static int dvide(int x,int y){
			return x/y;
		}

	}

public class Ex{
	public static void main(String [] args) {
		sum(10l,20l);
		sum(10,20);
		sum((long)2.9,(long)2.0);
		A.doOther();//在主程序访问方法不是该类的时候不能省略类名

	}
	public static void sum(long a,long b) {
		System.out.println(a+"+"+b+"="+(a+b));
	}
	
}
class A{
	public static void doOther() {
		System.out.println("你好");
	}
}

3.13重载


数据处理麻烦--->方法，方法之间相似--->重载‘ 

方法重载：多个方法之间相似，给他们起一个相同方法名，在调用的区别是依靠的是参数的数据类型
什么条件下满足方法重载1.在同一个类中2.方法名相同3.参数列表不同：类型不同 顺序不同 数量不同

public static void m(){}
pubiic static void m(int a){}

public static void m2(int a,double b){}
public static void m2(double a,int b){}

public static void m3(int a){}
public static void m3(double a){}

public static void m4(int a,int b){}
public static void m4(int b,int a){}
//****方法重载只和方法名，参数列表有关

3.14递归

public class RecursionTest01{
	public static void main(String [] args) {
		System.out.println("main begin");
		doSome();
	}
	public static void doSome(){
		System.out.println("dosome begin");
		doSome();//方法递归，
		System.out.println("doSome over");
	}
}
/*
main begin
dosome begin
dosome begin
...

*/
//什么是递归？
//方法自身调用自身,递归是很耗费内存的

3.13返回值return

深入return语句
1.带有return关键字的java语句只要执行，所在的方法执行结束
2.在同一个作用域中，return语句下面不能编写任何代码，因为这些代码永远执行不到，编译报错
3.在返回值是void方法中，使用return语句是为了结束当前方法

3.2对象

什么是对象？
new 运算符在堆内存中开辟的内存空间，称为对象
什么是引用？
引用是一个变量，只不过这个变量保存了某一个java对象的内存地址
java语言中程序员只能通过引用去访问堆内存的数据

//对象
/*no,age,name这个实例变量不能采用类名的方式直接访问，no,age,name是实例变量，对象级别的变量，变量存储在java对象的内部，必须先有对象，通过对象才能访问no,age,name这个实例变量
*/

public class OOtest
{
	public static void main(String [] args) {
		Student s =new Student();
		//通过一个类可以实例化n个对象
		//语法格式：new 类名（）；new 是运算符，他的作用是创建对象，在jvm堆内存中开辟新的内存空间
		//该内存空间有一个地址，该地址赋值给s,称为引用
	}
}
class Student
{
	int no;
	int age;
	String name;
}

3.2.1对象组合

//对象组合
public class OoTest04
{
	public static void main ( String [] args) {
		 //创建丈夫对象
		 Husband huang =new Husband();
		 huang.name="黄晓明";
		 //创建妻子对象
		 Wife bady=new Wife();
		 bady.name="bady";
		 //结婚，能通过妻子找到丈夫，能通过丈夫找到妻子
		 haung.w=bady;
		 bady.h=huang;
		 System.out.println(huang.name+"的妻子名字叫:"+bady.name);
		 System.out.println(bady.name+"的丈夫名字叫："+haung.name);
	}
	
}
//丈夫类
public class Husband
{
		String name;
		//丈夫对象当中包含妻子引用
		wife w;
}
//妻子类
public class Wife
{
	String name;
	//妻子对象当中含有丈夫引用
	Husband h;

}

4、jvm内主要三块内存空间

1.JVM主要包括三块内存空间
方法区内存，堆内存，栈内存
2.一个线程一个堆内存
3.方法不调用不分配所属的内存空间，调用的时候会在栈内存中分配，称为压栈。方法执行结束之后，该方法所属的内存空间释放，称为弹栈
4.栈中主要存储的是方法体当中的局部变量
5.方法的代码片段以及整个类的代码片段都会存储在方法区内存当中，在类加载的时候这些代码会载入
6.在程序执行过程中使用new运算符创建java对象存储在堆内存当中，对象内部有实例变量，所以实例变量存储在堆内存当中
7.变量分类：
局部变量（方法体中声明）
成员变量（类体内，方法体外）：实例变量，静态变量
8.静态变量存储在方法区内存
9.三块内存当中变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收处理器主要针对的是堆内存
/*
垃圾回收器[自动回收垃圾机制，GC机制]什么时候考虑将某个java对象内存回收？
当堆内存当中java对象成为垃圾数据的时候
什么时候堆内存中的java对象成为垃圾数据？
没有引用指向他们的时候
这个对象无法访问，因为访问对象只能通过引用的方式。
*/

public class OoTest05
{
	public static void main(String [] args) {
		Customer c=new Customer();
		System.out.println(c.id);
		c=pull;
		/*System.out.println(c.id);报错空引用访问实例相关数据，编译可以通过，但运行会出现空指针异常
*/

}

5、参数传值

//参数传值
public class Test02
{
	public static void main (String [] args) {
		User u =new User(20);
		add(u);/传递的是u变量中保存的值，该值是java对象的内存地址
			System.out.println("main-->"+u.age);//21
	}
	public static void add(User u){
		u.age++;
		System.out.println("add-->"+u.age);//21
	}
}
class User
{
	int age;
	public User(int age){
		this.age=age;
}
//方法在调用的时候涉及参数传值问题，传递的时候，java值遵循一种就是将变量中保存的“值”传递过去。
//只不过这个值有时候是字面值，有时候是内存地址。