------- android培训、java培训、期待与您交流! ----------
面向对象
面向对象:是一种思想,想学好Java必须掌握面向对象。
c语言是一门面向过程的语言,c语言强调的是功能行为。
Java面向对象的思想就是强调具有功能的对象。面向对象是把行动者变成了指挥者。
1. 是一种符合人们思考习惯的思想
2. 可以将复杂的事情简单化
3.将程序员从执行者转换成了指挥者
Java的开发过程,其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程,其实就是在管理和维护对象之间的关系。
类与对象
如图我们可以理解为:类是事物的描述,对象是实体(也可以理解为:类就是图纸,汽车就是对象。)
类:
使用计算机语言就是不断的描述现实生活中的事物,而java中描述事物通过类的形式体现。Java是用类class来描述对象的属性和行为,通过new创建对象,即是该类事物实实在在存在的个体。
如何用代码形式创建对象
描述小汽车
分析:
1,属性。
轮胎数。
颜色。
2,行为。
运行。
*/
class Car
{
int num;
String color;
void run()
{
//int num = 10;
System.out.println(num+"..."+color);
}
}
class CarDemo
{
public static void main(String[] args)
{
//在计算机中创建一个car的实例。通过new关键字。
Car c = new Car();// c就是一个类类型的引用变量,指向了该类的对象。
c.num = 4;
c.color = "red";
c.run();//要使用对象中的内容可以通过 对象.成员 的形式来完成调用。
}
}
成员变量和局部变量
之前我们用到的基本都是局部变量,现在我们将会使用成员变量。其实它两都是变量,规范写法上也没啥区别,都是标识符,但是在作用范围和内存中分配不同。
匿名对象
匿名对象是对象的简化形式,匿名对象两种使用情况。
1、当对对象方法仅进行一次调用的时。
2、匿名对象可以作为实际参数进行传递。
匿名对象。没有名字的对象 。
new Car();//匿名对象。其实就是定义对象的简写格式。
Car c = new Car();
c.run();
new Car().run();
1,当对象对方法仅进行一次调用的时候,就可以简化成匿名对象。
new Car().num = 5;
new Car().color = "green";
new Car().run();
//基本数据类型参数传递
class Demo
{
public static void main(String[] args)
{
int x = 3;
show(x);
System.out.println("x="+x);
}
public static void show(int x)
{
x = 4;
}
}
//引用数据类型参数传递
class Demo
{
int x = 3;
public static void main(String[] args)
{
Demo d = new Demo();
d.x = 9;
show(d);
System.out.println(d.x);
}
public static void show(Demo d)
{
d.x = 4;
}
}
对象的封装
(私有)private关键字:权限修饰符,用于修饰类中的成员(成员变量,成员函数)。
私有只在本类中有效。
将成员变量私有化,对外提供对应的set,get方法对其进行访问。构造函数
构造函数小特点
当一个类中没有定义构造函数时,那么系统就会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后,默认的构造函数就没有了。
构造函数和一般函数区别构造函数是在对象一建立就运行,给对象初始化。
一个对象建立,构造函数只运行一次。
一般方法是对象调用才执行,给是对象添加对象具备的功能。
一般方法可以被该对象调用多次。
什么时候定义构造函数当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
构造代码块和构造函数的区别:
构造代码块给对象进行初始化。对象一建立就运行。
构造代码块是给所以对象进行初始化。而构造函数是给对应的对象初始化。
构造代码块中定义的是对象共性的初始化内容。
this关键字
/*
当成员变量和局部变量重名,可以用关键字this来区分。
this : 代表对象。代表哪个对象呢?当前对象。
this就是所在函数所属对象的引用。
简单说:哪个对象调用了this所在的函数,this就代表哪个对象。
this也可以用于在构造函数中调用其他构造函数。
注意:只能定义在构造函数的第一行。因为初始化动作要先执行。
*/
class Person
{
private String name;
private int age;
Person()
{
name = "baby";
age = 1;
System.out.println("person run");
}
Person(String name)
{
this();
this.name = name;
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void speak()
{
System.out.println(this.name+":"+this.age);
}
}
this的应用:
当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
但凡本类功能内部使用到了本类对象,都用this表示。
this的两种用法
1、用于区分同名变量的情况,说的成员和局部同名的时候;
2、用于构造函数间调用。
static(静态)关键字
static的特点:
1,static是一个修饰符,用于修饰成员。
2,static修饰的成员被所有的对象所共享。
3,static优先于对象存在,因为static的成员随着类的加载就已经存在了。
4,static修饰的成员多了一种调用方式,就可以直接被类名所调用 。 类名.静态成员 。
5,static修饰的数据是共享数据,对象中的存储的是特有数据
当成员被静态修饰后,可以直接被类名调用。
格式:类名.静态成员
成员变量和静态变量的区别
1,两个变量的生命周期不同。
成员变量随着对象的创建而存在,随着对象的被回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2,调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3,别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4,数据存储位置不同。
成员变量数据存储在堆内存的对象中,所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据.
静态使用的注意事项:
1,静态方法只能访问静态成员。(非静态既可以访问静态,又可以访问非静态)
2,静态方法中不可以使用this或者super关键字。
3,主函数是静态的。
什么时候用静态
1,静态变量。
当分析对象中所具备的成员变量的值都是相同的 。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。
2,静态函数。
函数是否用静态修饰,就参考一点,就是该函数功能是否有访问到对象中的特有数据。
简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,
但是非静态需要被对象调用,而仅创建对象调用非静态的
没有访问特有数据的方法,该对象的创建是没有意义。
格式:
static
{
静态代码块中的语句。
}
特点:随着类的加载而执行,执行一次。并优先于主函数。用于给类进行初始化。
对象的初始化过程:
1、把类名.class文件加载到内存中。
2、执行该类中的static代码块,如果有得话,给该类进行初始化。
3、在堆内存中开辟空间,分配内存地址。给对象
4、在堆内存中建立对象的特有属性。并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码块初始化。
7、对对象进行对应构造函数初始化。
8、将内存地址赋给栈内存中的对象名变量。
主函数的构造说明
java中的工具类
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装。以便复用。下面我们以一个数组工具类为例,作一个文档说明书。
/**
建立一个用于操作数组的工具类,其中包含着常见的对数组操作的函数如:最值,排序等 。
@author 郭
@version
*/
public class ArrayTool
{
private ArrayTool(){}//该类中的方法都是静态的,所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
//可以将构造函数私有化。
/**
获取整型数组的最大值。
@param arr 接收一个元素为int类型的数组。
@return 该数组的最大的元素值
*/
public static int getMax(int[] arr)
{
int maxIndex = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;//
}
return arr[maxIndex];
}
/**
对数组进行选择排序。
@param arr 接收一个元素为int类型的数组。
*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
swap(arr,x,y);
}
}
}
/*
用于给数组进行元素的位置置换。
@param arr 接收一个元素为int类型的数组。
@param a
@param b
*/
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
获取指定的元素在指定数组中的索引.
@param arr 接收一个元素为int类型的数组。
@param key 要找的元素。
@return 返回该元素第一次出现的位置,如果不存在返回-1.
*/
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
/**
将int数组转换成字符串。格式是:[e1,e2,...]
@param arr 接收一个元素为int类型的数组。
@return 返回该数组的字符串表现形式。
*/
public static String arrayToString(int[] arr)
{
String str = "[";
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
str = str + arr[x]+", ";
else
str = str + arr[x]+"]";
}
return str;
}
}
在dos命令行中输入命令:javadoc -d Myhelp -author-version ArrayTool.java
Java中的javadoc工具就会帮我们完成API的制作。
单例设计模式
设计模式的概念:解决某一问题最行之有效的方法。
单例设计模式的作用:使一个类在内存中只存在一个对象。
步骤:
1、将构造函数初始化。
2、在类中创建一个本类对象。
3、提供一个访问方法可以获取到该对象。
单例设计模式有两种写法(背也要背下来)
1、饿汉式:也就是刚三部中的示例语句。它的特点是先初始化对象。
如:Single类一进内存,就已经创建好了对象。在实际开发中,出于安全考虑,建议使用饿汉式。
class Single
{
private static Single sin=new Single(); //直接创建对象,比较常用;
private Single(){}//构造函数私有化,使其他类中不能创建该类对象。
public static Single getInstance()//括号里面可以写入条件,从而实现可控性。
{
return sin;
}
}
2、懒汉式:它的特点对象是方法被调用时,才初始化,这也叫对象的延时加载。
如:在以下完整代码中,Single类进内存,对象还没有存在,只有调用了getInstance()方法时,才创建对象。
class Single
{
private static Single sin=null; //这里就是体现出懒汉,初始值定义为空,被调用时才创建对
private Single(){}//构造函数私有化,使其他类中不能创建该类对象。
public static Single getInstance() //括号里面可以写入条件,从而实现可控性。
{
if(sin==null)
sin=new Single();
return sin;
}
}