面向过程

Java是一个面向对象的语言。在一个面向对象的系统中，类（class）是数据和操作数据的方法的集合。数据和方法一起描述对象（object）的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的，使得子类可以从超类继承行为。在这个类层次体系中有一个根类，它是具有一般行为的类。Java程序是用类来组织的。

面向对象

OOP（Object Oriented Programming）面向对象编程。面向对象编程实质上就是对现实世界的对象进行建模操作。

类

我们把某些具有相同的属性和行为的事物抽象成一类。
类是模子，确定对象将会拥有的特征（属性）和行为（方法）
类的特点:

• 类是对象的类型
• 具有相同属性和方法的一组对象的集合

猫：
属性：颜色，年龄，体重
行为：睡觉，抓老鼠，吃食

小汽车类：
属性：颜色，马力，四个轮子
行为：行驶，停车

在java语言中万物皆对象（在java里面不是所有的东西都是对象，八种基本数据类型不是对象，jdk1.5以后对于八种基本数据类型都提供了包装类）。

对象

类是一个概念，对象是一个具体的实例。
“有什么”
属性：对象具有的各种静态特征
“能做什么”
方法：对象具有的各种动态行为

类和对象的关系

• 类是抽象的概念，仅仅是模板
• 对象是一个你能够看得到、摸得着的具体实体
• 类是对象的类型
• 对象是特定类型的数据
• 具体开发过程中，先定义类再实例化对象

类的定义

语法:

class 类名{属性方法}

注意:如果是一个类的情况，最好让类名和文件名一致。
类里面只能有属性和行为
类名：要见名之意，要用英文的单词，每一个英文单词的首字符要大写。

属性

在类中定义的变量就是属性，属性可以没有初始值，但是jvm会给属性一个默认值,只有属性才有默认值
基本数据类型的默认值如下表:

基本数据类型	默认值
byte	0
short	0
int	0
long	0
float	0.0
double	0.0
char	‘ ’
boolean	false

引用数据类型的默认值：null

方法

方法：对象具有的各种动态行为
语法:

public <static> 返回值  方法名字（数据类型 变量, 数据类型 变量……）{<return>
}

类的实例化

创建类的目的，就是创建对象（类的实例）
语法:

数据类型 变量 = new 数据类型();

实例:

上面实例创建了一个猫类

访问对象的属性:

对象.属性名

调用类的方法:

对象.方法（行为）名

实例:

创建对象的内存的结构

当我们运行类的时候会在内存中产生jvm
Jvm有栈，堆，数据共享区

• 栈：程序运行的时候基本数据类型和引用数据类型的引用所存储的位置,内存小，存取的速度快
• 堆：是对象存储的位置,内存大，存取的速度慢
• 数据共享区：存储共享数据的内存区

数据共享区:

Dog.class
lookHome()
sleep()//类中的对象方法是被当前类的所有对象共享的。

局部变量

凡是定义在方法内或者是语句块的变量都是局部变量。

如下：

局部变量的特点：

1. 作用范围：只限于所定义的大括号。
2. 存储的位置：存储在栈内存中。
3. 默认值：无，局部变量必须赋值。
4. 生命周期：所属的大括号结束就消失

class Demo1{public static void main(String[] args){//局部的变量只在它的所属的大括号和其子孙括号内有效int x = 0;if(x > 10){System.out.println(x);}}public static void add(){//定义一个变量int i = 0;{int x = 0;}//报错的System.out.println(x);}//方法的参数这个变量的作用域就是这个方法的体内public static void add(int a){}public static void multiply(){//循环的变量的定义的也是在循环体的大括号内有效for(int i=0;i<10;i++){}}	
}

注意：并不是只有基本数据类型才是局部变量

局部变量在使用之前必须要初始化，否则会报错

报错：

局部变量的生命周期

类的封装

面向对象的三大特征：封装、继承、多态
目的：提高数据安全性，通过封装，可以实现对属性的访问权限控制，同时增加了程序的可维护性。

封装性

封装的步骤

1. 属性用private私有
2. 使用set/get赋值,并用this引用
3. 调用方法（方法公有）

实例:

// 对System.out.println();的封装。
public class Test
{public static void test(String str){System.out.println(str);}
}调用public class Use{public static void main(String[] args){Test.test("封装")；}}

继承性

若一个类只允许继承一个父类，称为单继承；若允许继承多个父类，则称为多重继承。Java语言通过接口实现了多继承
实例:

Class A{
Public  void  A1(){System.out.println(“我是特立独行的鱼儿”);}
}
Class B extends A{}

多态性

在这里插入代码片public Class Parents { public void print() {System.out.println(“parents”);}
}
public Class Father extends Parents { public void print() {System.out.println(“father”); }
}
public Class Mother extends Parents {public void print() {System.out.println(“mother”);} 
}public Class Test {public void find(Parents p) { p.print();
}
public static void main(String[] args) {Test t = new Test();Father f = new Father();Mother m = new Mother();t.find(f);t.find(m);}
}

This关键字

对象方法中隐藏了一个this关键字, 如果那个对象调用了这个方法那么这个方法里面的this就是这个对象

class Person{String name;int age;public void info(){/*对象方法中隐藏了一个this关键字, 如果那个对象调用了这个方法那么这个方法里面的this就是这个对象
*/System.out.println(this);}
}public class TestPerson{public static void main(String[] args){//创建一个Person对象Person p = new Person();System.out.println(p);//调用infop.info();}	
}

This在封装中用来区分同名的变量和属性，带有this的是属性
实例：

class Person{private String name;private int age;public void setName(String name){//this.name是属性this.name = name;}public String getName(){return name;}public void setAge(int age){this.age = age;}public int  getAge(){return age;}
}

构造器

构造器本身是一个方法：

• 没有返回值，也没有void。
• 构造器的方法名必须和类名一致
• 在方法中定义要初始化的参数列表
  作用：创建对象，给对象赋初始值；

默认构造器

public Person(){System.out.println("我是被鱼儿调用的构造器");
}

一个类的构造器没有任何参数这就是默认构造器，如果不写的话也是默认存在的，方法体什么都没有，我们也可以显示的定义出来。

有参数的构造器

实例：

public Person(String name, int age){//给属性赋值this.name = name;this.age = age;}

使用有参数的构造器创建对象：

Person p1 = new Person("特立独行的鱼儿", 20);p1.info();

如果一个类里面存在着一个有参的构造器的话，那么无参数的默认构造器就会被覆盖，就不能使用，如果想要使用这个默认的构造器就必须把它显示的定义出来。

构造器直接的调用

public Person(String name, int age){this.name = name;this.age = age;}public Person(String name, int age, String gender){//通过this的用法调用本类的构造器/*this.name = name;this.age = age;*/this(name, age);this.gender = gender;}

通过this(变量，变量….)这种方式来调用本类的构造器，必须放在调用的第一行。

单例模式

我们以往创建对象的时候，通过一个类是可以创建很多个对象的，但是我们想要让一个类就只能创建一个对象。
懒汉模式
实例：

class Singleton{private static Singleton s;//给构造器私有化private Singleton(){}//私有化构造器之后，肯定不能被外部使用public static Singleton getInstance(){if(s == null){s = new Singleton();}return s;}
}class TestSingleton{public static void main(String[] args){Singleton s = Singleton.getInstance();Singleton s1 = Singleton.getInstance();Singleton s2 = Singleton.getInstance();System.out.println(s);System.out.println(s1);System.out.println(s2);}
}