一、关于面向对象&面向过程
概念:面向对象是相对面向过程而言,两者都是一种思想。面向过程强调的是功能行为,面向对象是将功能封装进对象,强调的是具备了功能的对象,所以说面向对象是基于面向过程的。
面向对象的三个特征:封装、继承、多态。
二、类和对象的关系
类:对现实生活中事物的描述
对象:就是这类事物,实实在在存在的个体
映射到Java中,描述就是class定义的类;具体对象就是Java在堆内存中用new建立的实体。
class Car
{
//描述颜色
String color = "red";
//描述轮胎数
int num =4;
//运行行为
void run()
{
System.out.println(color+".."+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//生产汽车,在Java中通过new操作完成
//其实就是在堆内存产生一个实体
Car c = new Car();//c就是一个类型变量,类类型变量指向对象
//需求:讲已有车的颜色改成bule,指挥该对象做使用。
//在Java中指挥方式是:对象.对象成员
c.color = "bule";
c.run();
Car c1 = new Car();
c1.run();//red 4
}
}
对象的特点在于封装数据,数据包含属性行为,想要操作对象的内容就指挥对象做事就OK
成员变量&局部变量
成员变量作用于整个类中;存在于堆内存中,因为对象的存在而存在。
局部变量作用于函数,或语句中;存在栈内存中。
匿名对象
匿名对象使用方法:
1.当对象的方法只调用一次时,就可以用匿名对象来完成,这样较为简化
如果对一个对象进行多个成员调用,必须给对象起名。
2.可以将匿名对象作为实际参数进行传递
范例:
TestNoName.java
01classPerson
02{
03 private String name = "张三" ;
04 private int age = 25 ;
05 public String talk()
06 {
07 return "我是: "+name+",今年: "+age+"岁" ;
08 }
09 }
10
11 public class TestNoName
12 {
13 public static void main(String[] args)
14 {
15 System.out.println(new Person().talk());
16 }
17 }
输出结果:
我是:张三,今年: 25 岁
程序说明:
1、 程序 1~9 行声明了一 Person 类,里面有 name 与 age 两个私有属性,并分别赋了初值。
2、 在程序第 15 行,声明了一 Person 匿名对象,调用 Person 类中的 talk()方法。
由程序中可以发现用 new Person()声明的对象并没有赋给任何一个 Person 类
对象的引用,所以此对象只使用了一次,之后就会被 Java 的垃圾收集器回收。
三、封装
封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
将变化隔离、便于使用、提高重用、提高安全性
封装原则:
将不需要对外提供的内容都隐藏起来;把属性都隐藏,提供公共方法对其访问
关键字:Private
权限修饰符;用于修饰类中的成员(成员变量,成员函数)。
私有只在本类中有效
私有仅仅是封装的一种形式
之所以对外提供访问方式,就是因为可以在访问方式中加入逻辑判断等语句;
对访问的数据进行操作,提高代码的健壮性。
构造函数
特点:函数名于类名相同;不用定义返回值类型;不可以写return语句
作用:给对象进行初始化
注意:
默认构造函数的特点、过个构造函数以重载的形式存在的
构造函数一个细节:当一个类中没有定义构造函数时,系统默认给该类加入一个空参数的构造函数。(方便该类进行初始化)
【 构造方法的定义格式】
class 类名称
{
访问权限 类名称(类型 1 参数 1,类型 2 参数 2, …)
{
程序语句 ;
… // 构造方法没有返回值
}
}
在使用构造方法的时候请注意:
1、 它具有与类名相同的名称(名称必须与类的名称相同)
2、 它没有返回值
构造函数和一般函数的区别:
1.构造函数是在对象一建立就运行,一般函数是在对象调用其的时候才运行,是给对象添加对象具备的功能;
2.一个对象建立,构造函数只运行一次,而一般函数可以被该对象调用多次。
什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
构造代码块
作用:给对象进行初始化
对象一建立就运行,而且优先于构造函数执行
构造代码块和构造函数的区别:
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化
构造代码块中定义的是不同对象共性的初始化内容
对象的比较
有两种方式可用于对象间的比较,它们是“ = =”运算符与 equals()方法,“ = =”
操作符用于比较两个对象的内存地址值是否相等, equals()方法用于比较两个对象的内容是否一致。
this 关键字
this表示当前对象,哪个对象在调用this所在函数,this就代表哪个对象
this语句:用于构造函数之间进行互相调用
this语句只能定义在构造函数的第一行,因为初始化要先执行
静态:static
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外还可以直接被类名调用, 类名.静态成员
Static 特点
1,随着类的加载而加载,也随着类的消失而消失。说明它的生命周期最长。
2,优先于对象存在
3,被所有对象所共享
4,可以直接被类名所调用
实例变量和类变量的区别:
1,存放位置
类变量随着类的加载而存在于方法区;
实例变量随着对象的建立而存在于堆内存中
2,生命周期
类变量生命周期最长,随着类的消失而消失
实例变量生命周期随着对象的消失而消失
class Person
{
string name; //成员变量,实例变量
static String country = “CN”;//静态成员变量,类变量
public static void show()
{
System.out.println(name+ “:::::::”+country);
}
}
class stasticDemo
{
public static void main(String[] args)
{
Person p =new person();
p.name =”zhangsan”;
System.out.println(p.country);
System.out.println(person.country);
}
}
静态static使用注意事项:
1,静态方法只能访问静态成员
非静态方法既可以访问静态也可以访问非静态
2,静态方法中不可以定义this,super关键字
因为静态优先于对象存在,所以静态方法中不可以出现this
静态有利有弊
利:对对象的共享数据进行单独空间的存储,节省空间
可以直接被类名词调用
弊:
生命周期过长,访问出现局限性
理解main()方法
public static void main(String [] args)
主函数:是一个特殊函数,作为程序入口,可以被JVM调用
由于 JVM需要调用类的 main()方法,所以该方法的访问权限必须是 public,又因为JVM在执行 main()方法时不必创建对象,所以该方法必须是 static 的,该方法接收一个 String 类型的数组参数,该数组中保存执行 Java 命令时传递给所运行的类的参数。
主函数定义:
public :代表该函数访问权限最大,表示公共方法
static :代表主函数随着类的加载就已经存在,表示此方法为一静态方法,可以 由类名直接调用
void :主函数没有具体的返回值
main :不是关键字,但是是一个特殊单词,可以被JVM识别
(String[] arr):函数的参数,参数类型是一个数组,该数组的元素是字符串,字符串类型的数组,接收运行时参数
JVM在调用主函数时,传入的是 new String[0];
什么时候使用静态
要从两方面入手:
因为静态修饰的内容有成员变量和函数
什么时候定义静态变量(类变量)?当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中
什么时候定义静态函数?当功能内部没有访问到非静态数据(对象的特有数据)
那么该功能可以定义成静态的
静态的应用——工具类
每一个应用程序都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。
可发现有一下问题:
1,对象是用于封装数据的,可是ArrayTool对象并未封装特有数据
2,操作数组的每一个方法都没有用到ArrayTool对象中的特有数据
这时就考虑,让程序更严谨,是不需要对象的。
可以将ArrayTool中的方法都定义成static的,直接通过类名调用即可
将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的
为了更严谨,强制让该类不能建立对象
可以通过将构造函数私有化完成。
代码范例:
public class ArrayTool
{
public static void main(String[] args)
{
int[] arr={7,2,23,47,61,9,6,};
int max=ArrayTooltest.getMax(arr);
System.out.println("max="+max);
selectSort(arr);
}
public static int getMax(int [] arr)
{
int max=0;
for(int i=1;i<arr.length;i++)
{
if(arr[i]>arr[max])
max=i;
}
return arr[max];
}
public static int getMin(int [] arr)
{
int min=0;
for (int i=1;i<arr.length;i++)
{
if (arr[i]<arr[min])
min=i;
}
return arr[min];
}
//选择排序法:一次用一个数与其他数挨着比较,符合条件就换位
public static void selectSort(int[] arr)
{
for(int i=0;i<arr.length-1;i++)
{
for(int j=i+1;j<arr.length ;j++)
{
if(arr[i]>arr[j])
{
swap(arr,j,j+1);
}
}
}
}
//冒泡排序法:相邻两个数进行比较,符合条件就换位
public static void bubbleSort(int [] arr)
{
for(int i=0;i<arr.length-1;i++)
{
for(int j=0;j<arr.length-i-1;j++)//-i:让每一次比较的数减少;-1:避免角标越界
{
if(arr[j]>arr[j+1])
{
swap(arr,j,j+1);
}
}
}
}
public static void swap(int[] arr,int a,int b)
{
int temp =arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
四、构造静态代码块
静态代码块格式
Static
{
静态代码块中的执行语句;
}
特点:随着类的加载而执行,只执行一次,用于给类进行初始化;并优先于主函数执行
对象初始化过程:
Person p = new Person(“zhangsan”,20)
该语句执行过程:
1,因为new用到了Person.class ,所以会先找到Person.class文件并加载到内存中,
2,执行该类中 static 代码块,如果有的话,会给Person.class类进行初始化
3,在堆内存中开辟空间,分配内存地址
4,在堆内存中建立对象的特有属性,并进行默认初始化
5,对属性进行显示初始化
6,对对象进行构造代码块初始化
7,对对象进行对应的构造函数初始化
8,将内存地址赋给栈内存中p变量
单例设计模式
设计模式:解决某一类问题最行之有效的方法
Java中23种设计模式
单例设计模式:解决一个类在内存只存在一个对象
想要保证对象唯一(实现思想)
1,为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该对象,只好在本类中,自定义一个对象
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式
这三步如何用代码体现?(实现步骤)
1,将构造函数私有化
2,在类中创建一个本类对象
3,提供一个方法可以获取到该对象
对于事物该怎么描述,还怎么描述
当需要将该事物的对象保证在内存中唯一时,就将以上3步加上即可
饿汉式:
这个是先初始化对象
Single类一进内存,就已经创建好了对象
例程:
class Single
{
private static Single s =new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
懒汉式:
对象是方法被调用时,才初始化,也叫做对象的延时加载,称为:懒汉式
Single 类进内存,对象还没有存在,只有调用getInstance方法时,才建立对象
例程:
//懒汉式:对象是方法被调用时,才初始化,也叫做对象的延时加载
class single
{
private static Single s =null;//Single 类进内存,对象还没有存在,只有调用getInstance方法时,才建立对象
private Single(){}
public static Single getInstance()
{
if(s==null)
s= new Single();
return s;
}
}
class
{
public static void main(String[] args)
{
System.out.println(“Hello World”);
}
}