------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
一.面向对象思想
1.概述:
面向对象是相对于面向过程而言的,面向过程强调的是功能,面向对象强调的是将功能封装进对象。
2.思想特点:
a:是符合人们思考习惯的一种思想
b:是将复杂的事情简单化了;
c:将程序员从执行者变成了指挥者
比如我要达到某种结果,我就寻找能帮我达到该结果的功能的对象,如我要洗衣服我就买洗衣机,
至于怎么洗我不管。
3.特征:
面向对象的三个特征:封装(encapsulation) 继承(inheritance) 多态(polymorphism)
完成需求:
a:先要去找具有所需的功能的对象来用。
b:如果该对象不存在,那么创建一个具有所需功能的对象。
c: 这样简化开发并提高复用。
在Java的开发过程,其实就是不断的创建对象,使用对象,指挥对象做事情。设计的过程,其实就是在管理和维护对象之间的关系。
二.类和对象
属性:对应类中的成员变量。
行为:对应类中的成员函数。
而对象即是该类事物实实在在存在的个体。
class Person
{
String name;
int age;
private void speak()
{
System.out.println("name="+name+",age="+age);
}
}
以上程序就定义了一个以人为对象的类,其中人这个对象具有姓名和年龄的属性,还具有说话的功能。而创建一个对象的格式:Person p = new Person();
这样就创建了一个人物对象,修改属性和使用功能的格式:
p.age=20;//对对象属性的修改
p.speak();//使用对象的功能
三.成员变量和局部变量的区别
1.作用域:四.匿名对象
2.应用场景:
a:只调用一次类中的方法。
b:可以作为实际参数在方法传递中使用
注:如果对一个对象进行多个成员调用,必须给这个对象起个名字。
五.封装
六.封装在代码中的体现_private(私有的)
1.private权限修饰符,用于修饰在类中私有的成员(成员变量、成员函数)。私有只在本类中有效.
常用之一:
将成员变量私有化,对外提供对应的set,get方法对其进行访问。提高对数据访问的安全性。
class Person{
//private:私有,是一个权限修饰符,用于修饰
//不希望别人直接访问赋值,需要通过私有化把属性进行隐藏
private int age ;
//通过提供set、get公共方法对其访问
public void setAge( int a){
//在set方法内可以对属性的赋值进行限制
if (a > 0 && a < 130){
age = a;
} else
System.out .println("错误的数据" );
}
public int getAge(){
return age ;
}
void speak(){
System.out .println("age = " + age);
}
}
class PersonDemo{
public static void main(String[] args){
Person p = new Person();
//通过其他方式访问
p.setAge(20);
p.speak();
//赋值不合法,set方法就不允许成功赋值
p.setAge(-20);
}
}
七.构造方法:
1.特点:方法名与类名相同
没有返回类型
没有返回值
2.作用:
构造函数是用于创建对象,并对其进行初始化赋值,对象一建立就自动调用相对应的构造函数。
3.构造方法的注意事项:
a:如果一个自定义类没有构造方法,系统会默认给出一个无参构造方法。
b:如果一个自定义类提供了构造方法,那么,系统将不再给出无参构造方法。
这个时候,你可以不使用无参构造方法。
如果你想使用,那么,就必须手动给出无参构造方法。
建议:一般情况下,我们的自定义类都要手动给出无参构造方法。
4.构造方法和成员方法的区别
a:格式区别
构造方法和类名相同,并且没有返回类型,也没有返回值。
普通成员方法可以任意起名,必须有返回类型,可以没有返回值。
b:作用区别
构造方法用于创建对象,并进行初始化值。
普通成员方法是用于完成特定功能的。
c:调用区别
构造方法是在创建对象时被调用的,一个对象建立,只调用一次相应构造函数
普通成员方法是由创建好的对象调用,可以调用多次
八.构造代码块:
1.作用:
给对象进行初始化,对象一建立就执行,而且由于构造函数执行。
2.构造代码块和构造函数的区别:
构造代码块是给所有不同对象的共同性进行统一的初始化
构造函数是给对应的对象进行初始化
九.this关键字
1.this关键字代表本类对象的一个引用,谁调用this所在的方法,this就代表谁。
2.this的使用场景:
a:用于区分同名成员变量和局部变量
b:在定义函数时,该函数内部要用用到调用该函数的对象时,因为此时对象还没有建立,故this代表此对象。
构造函数间调用,这个时候this(参数)必须作为第一条语句存在。
class Person{
private String name ;
private int age ;
Person(String name){
//通过this区分成员变量和局部变量
this.name = name;
}
Person(String name, int age){
//this也可以用于在构造函数中调用其他构造函数
this(name);
this.age = age;
}
public void speak(){
System.out.println(name + ":" + age);
}
}
class ConsDemo{
public static void main(String[] args){
Person p1 = new Person("张三" );
p1.speak();
Person p2 = new Person("李四" ,10);
p2.speak();
}
}
注:一般函数不能直接调用构造函数,因为
this
语句不能用在一般函数中,只能用在构造函数间。
十.Person p = new Person();在内存中做了哪些事情
1.将Person.class文件加载进内存中。
2.如果p定义在主方法中,那么就会在栈空间开辟一个变量空间p。
3.在堆内存给对象分配空间。
4.对对象中的成员进行默认初始化。
5.对对象中的成员进行显示初始化。
6.调用构造代码块对对象进行初始化。(如果没有就不执行)。
7.调用构造方法对对象进行初始化。对象初始化完毕!
8.将对象的内存地址赋值给p变量,让p变量指向该对象。
十一.static关键字
1.静态的意思,用来修饰成员变量和成员函数
2.静态的特点:
随着类的加载而加载
优先于对象存在
对所有对象共享
可以被类名直接调用
3.静态的注意事项
A:静态方法只能访问静态成员
为什么:因为静态的内容是随着类的加载而加载,它是先进内存的。
B:静态方法中不能使用this,super关键字
C:主方法是静态的
public static void main(String[] args)
public:公共的意思,是最大权限修饰符。
static:由于jvm调用main方法的时候,没有创建对象。
只能通过类名调用。所以,main必须用static修饰。
void:由于main方法是被jvm调用,不需要返回值。用void修饰。
main:main是主要的意思,所以jvm采用了这个名字。是程序的入口。
String[]:字符串数组
args:数组名
在运行的时候,通过java命令给args数组赋值。
格式:java MainTest hello world itcast
4.静态变量和成员变量的区别
a:调用方式
静态变量也称为类变量,可以直接通过类名调用。也可以通过对象名调用。
这个变量属于类。
成员变量也称为实例变量,只能通过对象名调用。这个变量属于对象。
b:存储位置
静态变量存储在方法区长中的静态区。
成员变量存储在堆内存。
c:生命周期
静态变量随着类的加载而存在,随着类的消失而消失。生命周期长。
成员变量随着对象的创建而存在,随着对象的消失而消失。
d:与对象的相关性
静态变量是所有对象共享的数据。
成员变量是每个对象所特有的数据。
5.静态的优点和弊端
优点:
对对象的共享数据进行单独空间的存储,节省内存,没有必要每个对象都存储一份
可直接被类名调用
弊端:
生命周期过长,随着类的消失而消失
访问出现权限,即静态虽好但只能访问静态
6什么使用使用静态呢?
a:当所有对象共享某个数据的时候,就把这个成员变量定义为静态修饰的。
b:当某个方法没有访问该类中的非静态成员,就可以把这个方法定义为静态修饰。
静态的生命周期比较长,所以一般不推荐使用。
7.静态代码块
a:它只执行一次,它比main还先执行。
b:执行顺序
静态代码块--构造代码块--构造方法
静态代码块格式:
static
{
静态代码块中的语句。
}
对象的初始化过程:
定义一个新对象都做了哪些事情?
1、把类名.class文件加载到内存中。
2、执行该类中的static代码块,如果有得话,给该类进行初始化。
3、在堆内存中开辟空间,分配内存地址。给对象
4、在堆内存中建立对象的特有属性。并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码块初始化。
7、对对象进行对应构造函数初始化。
8、将内存地址赋给栈内存中的对象名变量。
静态代码例:
/*
static 特点:
1:随着类的加载而加载
2:优先于对象存在
3:被类中所有的对象共享
4:可以通过类名调用
建议调用静态成员时用类名调用
静态修饰的内容一般我们称其为:与类相关的,类成员
*/
class Student{
String name ="张三";
static int classId = 1109 ;
}
class StudentDemo{
public static void main(String[] args) {
//创建对象
Student s = new Student();
//System.out.println(s.name);
//System.out.println(s.classId);//因为在有对象之前就有了静态成员,所以你用对象去调用,是可以的.
//没有被static修饰的变量能被类名调用吗?
//System.out.println(Student.name);不能
//直接通过类名调用静态成员
System.out.println(Student.classId);
}
}
十二.制作API
API(全拼):ApplicationProgram Interface 应用程序编程接口。
1.类中的内容需要用文档注释。
2.使用JDK\bin目录下的javadoc工具。
格式:javadoc -d 目录 -author-version ArrayTool.java
Java中的javadoc工具就会帮我们完成说明文档也称API的制作。
知识扩展:
主函数:主函数是一个特殊的函数。作为程序的入口,可以被jvm调用。
主函数的定义:
public static void main(String[] arr/args)
public:代表着该函数访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别,
(String[] arr):函数的参数,参数类型是一个数组,该数组 中的元素是字符串。字符串类型的数组。
args:arguments 参数。唯一可以更改的地方。
主函数是固定格式的:被JVM识别。
/**
这是一个可以对数组进行相关操作的工具类,该类提供了取数组的最值、排序等功能。
@author Godream
@version V1.0
*/
//类名权限要最大才能创建说明书文档
public class ArrayTool
{
/**
空参数构造函数
*/
private ArrayTool() //私有化构造函数是为了让其不能创建对象。
{
}
/**
这个功能用于得到int类型数组中的最大值
@param arr 接收一个int类型的数组
@return 返回接收的该数组的最大值
*/
public static int getMax(int[] arr)
{
int max=0;
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
/**
这个功能用于得到int类型数组中的最小值
@param arr 接收一个int类型的数组
@return 返回该数组的最小值
*/
public static int getMin(int[] arr)
{
int min=0;
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
/**
对int类型数组进行选择升序排列
@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);
}
}
}
/**
对int类型数组进行冒泡升序排列
@param arr 接收一个int 类型数组
*/
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1;x++ )
{
for (int y=0;y<arr.length-x-1;y++ )
{
if(arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}
}
/**
对数组中的两个元素进行位置交换
@param arr 接收一个int类型的数组
@param a 要置换的元素角标
@param b 要置换的元素角标
*/
private static void swap(int[] arr,int a,int b)
{
arr[a]=arr[b]+(arr[b]=arr[a])*0;
}
/**
遍历数组:打印数组中所有元素,形式为:[elemet1,elemet2,...]
@param arr 接收一个int类型的数组
*/
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x=0; x<arr.length-1; x++)
{
System.out.print(arr[x]+",");
}
System.out.println(arr[arr.length-1]+"]");
}
}
单例设计模式
设计模式的概念:解决某一问题最行之有效的方法。java中共有23种设计模式。
接下来我们讲解其中的一种:单例设计模式。
单例设计模式的作用:使一个类在内存中只存在一个对象。
用代码实现单例设计模式需要做三部:
1、将构造函数初始化。
例:private Single(){}
2、在类中创建一个本类对象。
例:private static Single s= newSingle();
3、提供一个访问方法可以获取到该对象。
例:public static Single getInstance()
{
returns;
}
单例设计模式只是为了保证内存中的对象唯一,其他在类中该怎么描述吗,还是怎么描述。
单例设计模式有两种写法:
1、饿汉式:也就是刚三部中的示例语句。它的特点是先初始化对象。如:Single类一进内存,就已经创建好了对象。在实际开发中,出于安全考虑,建议使用饿汉式。
class Single
{
private static Single s=new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
2、懒汉式:它的特点对象是方法被调用时,才初始化,这也叫对象的延时加载。如:在以下完整代码中,Single类进内存,对象还没有存在,只有调用了getInstance()方法时,才创建对象。
class Single
{
private static Single s=null;
private Single(){}
public static Single getInstance()
{
if(s==null)
s=new Single();
return s;
}
}
知识拓展:
主函数:
主函数是一个特殊的函数。作为程序的入口,可以被JVM调用。
主函数的定义:
public:代表着该函数访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被JVM识别。
(String[] arr):函数的参数,参数类型是一个数组,该数组中的元素是字符串。字符串类型的数组。
args:arguments 参数 。唯一可以更改的地方。
主函数是固定格式的:被JVM识别。