本文共 4909 字，大约阅读时间需要 16 分钟。

面向过程

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 
   
     返回值  方法名字（数据类型 变量, 数据类型 变量……）{
   	
    
     }
    
   

类的实例化

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

语法:

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

实例:

上面实例创建了一个猫类

访问对象的属性:

对象.属性名

调用类的方法:

对象.方法（行为）名

实例:

创建对象的内存的结构

当我们运行类的时候会在内存中产生jvm

Jvm有栈，堆，数据共享区

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

数据共享区:

Dog.classlookHome()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);		//调用info		p.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);	}}

转载地址：https://blog.csdn.net/weixin_43853746/article/details/107786465 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！