构造函数：
构造函数的作用 : 给对应的对象进行初始化。
构造函数的定义的格式：
修饰符 函数名(形式参数){
函数体...
}构造函数要注意的细节：
1. 构造函数 是没有返回值类型的
2. 构造函数的函数名必须要与类名一致
3. 构造函数并不是由我们手动调用的，而是在创建对应的对象时，jvm就会主动调用到对应的构造函数
4. 如果一个类没有显式的写上一个构造方法时，那么java编译器会为该类添加一个无参的构造函数的
5. 如果一个类已经显式的写上一个构造方法时,那么java编译器则不会再为该类添加一个无参的构造方法
6. 构造函数是 可以在一个类中以函数重载的形式存在多个的疑问：创建对象时，jvm就会调用到对应的构造方法，那么我们以前没有学构造方法，那么以前创建对象时，jvm是否 也会调用构造方法呢？如果有？构造方法从何而来呢？
会调用， java编译器在编译的 时候给加上去的。-
jdk提供了一个java开发工具(javap.exe)给我们进行反编译的。
- javap 反编译工具的使用格式：
javap -c -l -private 类名
- javap 反编译工具的使用格式：
疑问： java编译器添加的无参构造方法的权限修饰符是什么？
与类的权限修饰是一致的。-
构造函数与普通函数的区别：
- 返回值类型的区别：
1. 构造函数是没有返回值类型的
2. 普通函数是有返回值类型的, 即使函数没有返回值, 返回值类型也要写上void - 函数名的区别：
1. 构造函数的函数名必须要与类名一致
2. 普通函数的函数名只要符合标识符的命名规则即可 - 调用方式的区别：
1. 构造函数是在创建对象的时候由jvm调用的
2. 普通函数是由我们使用对象调用的, 一个对象可以对象多次普通的函数 - 作用上的区别：
1. 构造函数 的作用用于初始化一个对象
2. 普通函数是用于描述一类事物的公共行为的
- 返回值类型的区别：
//婴儿类
class Baby{
int id; //身份证
String name; //名字
//构造函数
public Baby(int i , String n){
id = i;
name = n;
System.out.println("baby的属性初始化完毕！！");
}
//无参 的构造函数
public Baby(){
System.out.println("无参的构造函数被调用了..");
}
//哭
public void cry(){
System.out.println(name+"哇哇哭...");
}
}
class Demo2
{
public static void main(String[] args)
{
//创建一个baby对象
Baby b1 = new Baby(110,"狗娃"); //婴儿诞生 白户
System.out.println("编号："+ b1.id +" 姓名："+ b1.name);
b1.cry();
b1.cry();
/*
//黑户
Baby b2 = new Baby();
new Baby();
b2.id = 112;
b2.name = "狗剩";
System.out.println("编号："+ b2.id +" 姓名："+ b2.name);
*/
}
}
构造代码块
构造代码块的作用 : 给对象进行统一的初始化
构造函数的作用 : 给对应的对象进行初始化
构造代码块的格式 :
{
构造代码块
}
注意 : 构造代码块的大括号必须位于成员位置上。-
代码块的类别 :
- 构造代码块
- 局部代码块 : 大括号位于方法之内
作用 : 缩短局部变量的生命周期, 节省一点点内存 - 静态代码块 : static
class Baby{
int id; //身份证
String name; //名字
//构造代码块...
{
//System.out.println("构造代码块的代码执行了......");
}
//带参构造函数
public Baby(int i , String n){
id = i;
name = n;
}
//无参构造方法
public Baby(){
}
public void cry(){
System.out.println(name+"哇哇哭...");
}
}
class Demo4
{
public static void main(String[] args)
{
Baby b1 = new Baby(110,"狗娃"); // 狗娃 狗剩 铁蛋
System.out.println("编号："+ b1.id + " 名字："+b1.name);
/*
System.out.println("编号："+ b1.id + " 名字："+b1.name);
new Baby(112,"狗剩");
new Baby();
*/
}
}
- 构造代码块要注意的事项：
- java编译器编译一个java源文件的时候，会把成员变量的声明语句提前至一个类的最前端
- 成员变量的初始化工作其实都在在构造函数中执行的
- 一旦经过java编译器编译后，那么构造代码块的代码块就会被移动构造函数中执行，是在构造函数之前执行的，构造函数的中代码是最后执行的
- 成员变量的显示初始化与构造代码块 的代码是按照当前代码的顺序执行的
权限修饰符
- 介绍 : 权限修饰符就是控制被修饰的成员的范围可见性
- 关键字:
- public(公共)
- protected(受保护)
- default(缺省)
- private (大到小)
public protected default private
同一个类 true true true true
同一个包 true true true false
子父类 true true false false
不同包 true false false false
- 注意： 在不同包下面只有public 与 protected 可以访问，而且protected必须是在继承关系下才能够访问
打jar包
- 如何打jar包? 需要使用到jdk的开发工具（jdk\bin\jar.exe)
- jar的用法：
使用格式 : jar cvf jar文件的名字 class文件或者是文件夹 - 打jar包要注意的事项：
- 一个程序打完了jar之后 必须要在清单文件上指定入口类： 格式 Main-Class: 包名.类名
- jar包双击运行仅对于图形化界面的程序起作用，对控制台的程序不起作用
- jar文件的作用：
- 方便用户快速运行一个项目
- 提供工具类以jar包的形式给别人使用
- 如果其他人使用jar包里面的类, 必须要先设置classpath(出现classpath-设置class文件的所在路径)路径: set classpath ./myUtil.jar;
jre = jvm+ 核心类库
package qq;
import javax.swing.*;
class Demo
{
public static void main(String[] args)
{
System.out.println("QQ程序..");
JFrame frame = new JFrame("QQ程序");
frame.setSize(400,500);
frame.setVisible(true); //设置窗口可见。
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
模板模式
解决某类事情的步骤有些是固定的，有些是会发生变化的，那么这时候我们可以为这类事情提供一个模板代码，从而提高效率
-
模板模式的步骤：
- 先写出解决该类事情其中 的一件的解决方案
- 分析代码，把会发生变化的代码抽取出来独立成一个方法, 把该方法描述成一个抽象的方法
- 使用final修饰模板方法，防止别人 重写你的模板方法
需求: 编写一个计算程序运行时间的模板
abstract class MyRuntime{
public final void getTime(){
long startTime = System.currentTimeMillis(); //记录开始的时间
code();
long endTime = System.currentTimeMillis(); //记录结束的时间.
System.out.println("运行时间 ："+ (endTime-startTime));
}
public abstract void code();
}
class Demo11 extends MyRuntime
{
public static void main(String[] args)
{
Demo11 d = new Demo11();
d.getTime();
}
//code方法内部就写要计算运行时间的代码；
public void code(){
int i = 0;
while(i<100){
System.out.println("i="+i);
i++;
}
}
}
finally 块
- finally块的使用前提是必须要存在try块才能使用
- finally块的代码在任何情况下都会执行的，除了jvm退出( System.exit(0) )的情况
- finally非常适合做资源释放的工作，这样子可以保证资源文件在任何情况下都会被释放
- try块的三种组合方式：
- 比较适用于有异常要处理，但是没有资源要释放的
try{
可能发生异常的代码
}catch(捕获的异常类型 变量名){
处理异常的代码
}
- 比较适用于既有异常要处理又要释放资源的代码
try{
可能发生异常的代码
}catch(捕获的异常类型 变量名){
处理异常的代码
}finally{
释放资源的代码;
}
- 比较适用于内部抛出的是运行时异常，并且有资源要被释放
try{
可能发生异常的代码
}finally{
释放资源的代码;
}
class Demo
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
div(4,0);
}
public static void div(int a, int b){
try{
if(b==0){
System.exit(0);//退出jvm
}
int c = a/b;
System.out.println("c="+ c);
}catch(Exception e){
System.out.println("出了除数为0的异常...");
throw e;
}finally{
System.out.println("finall块的代码执行了..");
}
}
}
- fianlly释放资源的代码
import java.io.*;
class Demo
{
public static void main(String[] args)
{
FileReader fileReader = null;
try{
//找到目标文件
File file = new File("f:\\a.txt");
//建立程序与文件的数据通道
fileReader = new FileReader(file);
//读取文件
char[] buf = new char[1024];
int length = 0;
length = fileReader.read(buf);
System.out.println("读取到的内容："+ new String(buf,0,length));
}catch(IOException e){
System.out.println("读取资源文件失败....");
}finally{
try{
//关闭资源
fileReader.close();
System.out.println("释放资源文件成功....");
}catch(IOException e){
System.out.println("释放资源文件失败....");
}
}
}
}
包
java中的包就相当于windows文件夹
-
包的作用：
- 解决类名重复产生冲突的问题
- 便于软件版本的发布
定义包的格式：package 包名
包名命名规范：包名全部小写
-
包语句要注意的事项：
- package语句必须位于java文件中中第一个语句
- 如果一个类加上了包语句，那么该类的完整类名就是: 包名.类名
- 一个java文件只能有一个包语句
- 问题 : 每次编译的时候都需要自己创建一个文件夹，把对应 的class文件存储到文件夹中。烦！！！
解决方法: javac -d 指定类文件的存放路径 java源文件
package aa;
class Demo1
{
public static void main(String[] args)
{
System.out.println("这个是Demo1的main方法...");
}
}
导入包的一些注意点
问题： 当有了包之后类与类之间的访问每次都必须要写上包名, 如何避免这种情况 ?
解决方案 : sun提供导包语句让我们解决该问题导包语句作用 : 简化书写 ( 误区： 把一个类导入到内存中 )
导包语句的格式 : import 包名.类名; ( 导入xxx包中某个类 )
-
导包语句要注意的细节：
- 一个java文件中可以出现多句导包语句
- "*"是导包语句的通配符。可以匹配任何的类名
- import aa.*; 是不会作用于aa包下面的子包的
推荐使用：import 包名.类名; 因为使用*通配符会导致结构不清晰
-
什么时候使用import语句:
- 相互访问的两个类不是在同一个包下面，这时候就需要使用到导包语句
- java.lang 是默认导入的, 不需要我们自己导入
package aa;
public class Demo {
/*
static{
System.out.println("这个是Dmeo3的静态代码块...");
}
*/
public void print(){
System.out.println("这个是Dmeo3的print方法...");
}
}
package bb;
import aa.Demo3;
import java.util.Arrays;
class Demo
{
public static void main(String[] args)
{
int[] arr = {1,234,2};
Arrays.sort(arr);
Object o = new Object();
Demo3 d = new Demo3();
d.print();
/*
Demo5 d2 = new Demo5();
d2.test();
*/
}
}
