包
*@包的三大作用:
1.区分相同名字的类(一个包里类名不能重名)
2.当类很多时,可以很好的管理类(仿照Java API文档)
3.控制访问范围
***包的基本语法:
package com.wyedu;
1.package 关键字:表示打包。
2.com.wyedu :表示包名。
***包的本质分析:
实际上就是创建不同的文件夹/目录来存放类文件 。
***包的命名:
-命名规则:
只能包含数字、字母、下划线、小圆点,但不能用数字开头,不能是关键字或保留字。
-命名规范:
一般是,小写字母+小圆点 比如: com.公司名.项目名.业务模块名
ect:com.sina.crm.user//用户模块
com.sina.crm.order//订单模块
com.sina.crm.utils//工具类
*@常用的包:
一个包下,包含很多的类,常用的有:
-----java.lang.* //lang包是基本包,默认引入,不需要再引入
-----java.util.* //util包,系统提供的工具包,工具类,使用Scanner
-----java.net.* //网络包,网络开发
-----java.awt.* //是做java的界面开发,GUL
***如何引入包?
文件:package exercise.Import01.java
语法:import包;
我们引入一个包的主要目的是要使用该包下的类。
比如:import java.util.Scanner;就只是引入一个类Scanner。
import java.util.*;表示将java.util包所有类都引入。
-建议:需要哪个类就导入哪个类。不建议使用*导入。
*@注意:
1.package的作用是生命当前类所在的包,需要放在class的最上面,一个类中最多只有一个package。
2.import指令位置放在package的下面,在类定义的前面,可以有多句且没有顺序前后。
访问修饰符
***基本介绍:
java提供四种访问修饰符号控制方法和属性(成员变量)的访问权限(范围)。
-公开级别:public,对外公开。
-受保护级别:protected,对子类和同一个包中的类公开。
-默认级别:没有修饰符号,对包中的类公开,但不对子类公开。
-私有级别:private,只有类本身可以访问,不对外公开。
*@注意:
1.修饰符可以用来修饰类中的属性、成员方法以及类
2.只有默认的和public才能修饰类,并且遵循上述访问权限的特点。
3.成员方法的访问规则和属性完全一样。
*@命名规范:
1:包(package):将公司域名反转作为包名。比如www.sohu.com
对于包名:每个字母都需要小写。***@但是可以大写
比如:com.sohu.test;该包下的Test类的全名是:com.sohu.Test.java 。
如果定义类的时候没有使用package,那么java就认为我们所定义的类位于默认包里面(default package)。
2:类:首字母大写,如果一个类由多个单词构成,那么每个单词的首字母都大写,而且中间不使用任何的连接符。尽量使用英文。如ConnectionFactory
3:方法:首单词全部小写,如果一个方法由多个单词构成,那么从第二个单词开始首字母大写,不使用连接符。addPerson
4:属性:与方法相同。如ageOfPerson
5:常量:所有单词的字母都是大写,如果有多个单词,那么使用下划线连接即可。
***面向对象编程三大特征:
面向对象编程有三大特征:封装、继承和多态。
封装
***封装:(encapsulation)
就是把抽象的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,
程序的其他部分只有通过被授权的操作[方法],才能对数据进行操作。
***优点:
1.隐藏实现细节: 方法(连接数据库)<--调用(传入参数..)
2.可以对数据进行验证,保证安全合理。
***实现:
1.将属性进行私有化private【让外部不能直接修改属性】
2.提供一个公共的set方法,用于对属性判断并赋值。
public void setXxx(类型 参数名){//Xxx表示某个属性
//加入数据验证的业务逻辑
属性 = 参数名;
}
3.提供一个公共的get方法,用于获取属性的值。
public 数据类型 getXxx(){//权限判断
return xx;
}
***将构造器和setXxx方法相结合。
*@equals方法:
*@equals和==的区别:
equals :
是Object类中的一个方法,只能判断引用类型。
##默认判断的是地址是否相同,子类中往往重写该方法,用于判断内容是否相等。常见使用Integer,String。
-基本类型Java自动重写equals方法,只比较内容。
-String类型的equals方法也重写了,也只比较字符串的内容。
== :
是一个比较运算符,不是一个方法。
(1) == : 既可以判断基本类型,又可以判断引用类型。
(2) == : 如果判断基本类型,判断的是值是否相等。
(3) == : 如果判断的是引用类型,判断的是地址是否相等,即判断是否是同一个对象。
***@hashCode方法:
1.提高具有哈希结构的容器的效率。
2.两个引用,如果指向同一个对象,则哈希值肯定是一样的。
3.两个引用,如果指向的是不同对象,则哈希值是不一样的。
4.哈希值主要根据地址来的,但是不能完全将阿悉知等同于地址。
5.后面在学习集合时,其中吐过需要的话,也会重写hashCode。
***@finalize:
(1)当对象被回收时,系统自动调用该对象的finalize方法。子类可以重写该方法,做一些释放资源的操作。
(2)什么时候被回收:当某个对象没有任何引用时,中的JVM就认为这个对象是一个垃圾对象,就会使用垃圾回收机制来销毁对象。
在销毁该对象前,会先调用finalize方法。
(3)垃圾回收机制的调用是由系统来决定的(即有自己的GC算法),也可以通过System.gc()主动的触发垃圾回收机制。
多态
***基本介绍:多态(多种状态)
方法或对象具有多种形态,是面向对象的第三大特征,多态是建立在封装和继承的基础上的。
***多态的具体体现:
1.方法的多态:
*@重写和重载就体现多态。
2.对象的多态:
*@重点:
1.一个对象的编译类型和运行类型可以不一致,也可以一致。
2.编译类型在定义对象时就确定了,不能改变。
3.运行类型是可以变化的。
4.编译类型看定义:= 的左边;
运行类型看: = 的右边。
***特别注意:
-多态的@前提:
两个对象(类)存在继承关系。(多态是建立在封装和继承之上的)
向上转型和向下转型
-多态的@向上转型:
1.本质:父类的引用指向了子类的对象。
2.语法:
父类类型 引用名 = new 子类类型();
3.特点:①编译类型看左边,运行类型看右边。
②可以调用父类中的所有成员(须遵守访问权限)。
③不能调用子类中的特有成员。【调用是通过编译器来调用的,父类中没有子类的特定成员,所以无法调用。】
④最终运行效果看子类的具体实现。
【在编译阶段能调用的成员,是由编译类型来决定的】
-多态的@向下转型:
1.语法:
子类类型 引用名 = (子类类型)父类引用;
2.只能强转父类的引用,不能强转父类的对象。
3.要求父类的引用必须指向的是当前目标类型的对象。
4.可以调用子类类型中的所有成员。
***细节:
1.@属性没有重写之说,属性的值看编译类型。
2.instanceof比较操作符,用于判断对象的 *@运行类型 是否为XX类型或其子类型。
***@@@动态绑定机制:(dynamicbinding)
(1)当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定。
(2)当调用对象属性时,没有动态绑定机制,哪里声明,哪里使用。
***@多态的应用——————多态数组和多态参数:
多态数组:
(1)数组的定义类型为父类类型,里面保存的实际元素类型为子类类型。
多态参数:
(2)方法定义的参数类型为父类类型,实参类型允许为子类类型。
静态变量/方法
***类变量
又叫做静态变量,是被某一个类的所有对象共享的。
***无论静态变量的地址是在堆中还是在方法区中,都不影响使用。
【在jdk1.7.0以上的版本前是放在方法区中的,在之后是放在定义类型的Class对象中。Class对象如同堆中的其他对象一样,存在于GC堆中】
*** 静态变量是在类加载的时候生成的。
【总的来说:static变量是保存在class实例的尾部,Class对象确实在堆中】
***
-什么是类变量?
类变量也叫静态变量/静态属性,是该类的所有对象共享的一个变量,任何一个该类的对象去访问它时,取到的都是相同的值,
同样任何一个该类的对象去修改它时,修改的也是同一个变量。
-如何定义类变量?
定义语法:
访问修饰符 static 数据类型 变量名;[推荐这种用法]
static 访问修饰符 数据类型 变量名;
-如何访问类变量?
类名.类变量名;[推荐使用]
或者
对象名.类变量名;【静态变量的访问修饰符的访问权限和范围 和普通属性是一样的】
-什么时候需要使用类变量?
当问们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量)
比如:定义学生类,统计所有学生共交多少钱时。
-类变量与实例变量(普通属性)的区别?
类变量是该类的所有对象共享时,而实例变量是每个对象独享的。
-加上static成为类变量或静态变量,否则则称为实例变量/普通变量/非静态变量。
-类变量可以通过 类名.类比那两名 或者 对象名.类变量名 来访问,但是Java设计者推荐我们使用第一种方式进行访问。
【前提是符合访问修饰符的范围】
-实例变量不能通过 类名.类变量名 方式访问。
-类变量是在类加载时就开始初始化了,也就是说,即使没有创建对象,只要类加载了,就可以使用类变量了。
-类变量的生命周期是随类的加载开始,随着类的消亡而销毁。
***@类方法:
-基本介绍:
* 类方法也叫做静态方法。
-形式:
* 访问修饰符 static 数据返回类型 方法名(){} [推荐]
或者
* static 访问修饰符 数据返回类型 方法名(){}
-类方法的调用:
* 使用方式:
* 类名.类方法名 或者 对象名.类方法名
【前提仍然是要满足访问修饰符的访问权限和范围】
***@注意:
1.类方法和欧统方法都是随着类的加载而加载,将结构信息储存在方法区。
-类方法中无this参数。(即类方法中不能使用this)
-普通方法中隐含着this的参数。
2.类方法可以通过类名调用,也可以通过对象名调用。
3.普通方法和对象有关,需要通过对象名调用,比如对象名.方法名(参数),不能通过类名调用。
4.类方法中不允许使用和对象有关的关键字,比如this和super。
普通成员(成员方法)可以。
5.类方法/静态方法中,只能访问静态变量或静态方法。
6.普通成员方法,及可以访问普通变量/方法,也可以访问静态变量/方法。
总结:静态方法只能访问静态成员;非静态的方法可以访问静态成员和非静态成员【遵守访问权限】
***深入理解main方法:
-解释main()方法的形式: public static void main(String[] args){}
1.main方法是Java虚拟机调用的。
2.Java虚拟机需要调用类的main()方法,所以该方法的访问权限必须是public。
3.Java虚拟机在执行main()方法时不必创建对象,所以该方法必须是static。
4.该方法接收String类型的数组参数,该数组中保存执行Java命令时传递给所运行的类的参数。
5.Java执行的程序 参数1 参数2 参数3
![](https://i-blog.csdnimg.cn/blog_migrate/8eb46493e92b7c49651bb14282c2ae0a.png)
*@注意:
(1)在main()方法中,我们可以直接调用mian方法所在类的静态方法或静态属性。
(2)但是,不能直接访问该类中的非静态方法,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态方法。
(3)如果我们要想在main方法中访问非静态成员/方法,就需要先创建对象,再调用即可。【创建一个主方法所在类的对象】
***@代码块:
-基本介绍:
代码块又称为初始化块,属于类中的成员(即是类的一部分),类似于方法,将逻辑语句封装在方法体中,通过{}包围起来。
但和方法不同,没有方法名,没有返回,没有参数,只有方法体,而且不用通过对象或者显式调用,而是加载类时,或创建
对象时隐式调用。
-基本语法:
[修饰符]{
代码
};
*@注意:
1.修饰符,要写的话也只能写static,不然就不写。
2.代码块分为两类,使用static修饰的叫做静态代码块,没有static修饰的,叫做普通代码块。
3.逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断、等)
4.;可以写上,也可以省略(可有可无)
*@优点:
1.相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化的操作。
2.如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的复用性。
*@细节:
(1)static代码块也叫做静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行,并且只会执行一次。
如果是普通代码块,每创建一个对象就执行。
(2)类什么时候被加载?
-①创建对象实例时(new)。
-②创建子类对象实例,父类也会被加载。而且父类先被加载,子类后被加载。
-③使用类的静态成员时(静态属性/方法)。而且代码块先被加载,静态成员后被加载。
(3)普通的代码块在创建对象实例时会被隐式的调用。被创建一次就调用一次。
如果只是使用类的静态成员时,普通代码块并不会执行【因为普通代码块是在创建对象时才会被调用,使用静态成员时不用创建对象】
(4)创建一个对象时,在一个类中 调用的顺序是:
-①调用静态代码块和静态属性初始化。
【注意:静态代码块和静态属性初始化调用的优先级一样,如果有多个代码块和多个静态变量初始化,则按照他们的定义顺序调用】
-②调用普通代码块和普通属性的初始化。
【注意:普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性,则按定义顺序调用】
-③调用构造方法。
(5)构造方法/构造器的最前面其实隐含了super()和调用普通代码块。
(6)我们看一下创建一个子类时(继承关系),他们的静态代码块,静态属性初始化,普通代码块,普通属性初始化,构造方法的调用书顺序:
1.父类的静态代码块和静态属性(优先级一样,按定义顺序执行)
2.子类的静态代码块和静态属性(优先级一样,按定义顺序执行)
3.父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
4.子类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
5.父类的构造方法。
6.子类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
7.子类的构造方法。
(7)静态代码块只能调用静态成员(静态属性/方法),普通代码块可以调用任意成员。
下部分学习计划:
抽象类、接口、枚举、异常处理