day01

1.抽象类

（1）抽象类的应用场景：

我们在描述一类事物的时候，发现该种事物确实存在着某种行为，但是这种行为目前不是具体的，那么我们可以抽取这种行为的声明，但是不去实现该种行为，这时候这种行为我们称作为抽象的行为，我们就需要使用抽象类。

（2）抽象类要注意的细节：

1.如果一个函数没有方法体，那么该函数必须要使用abstract修饰，把该函数修饰成抽象的函数。

2.如果一个类出现了抽象的函数，那么该类也必须使用abstract修饰。

3.如果一个非抽象类继承了抽象类，那么必须把抽象类的所有抽象方法全部实现。

4.抽象类可以存在非抽象方法，也可以存在抽象的方法。

5.抽象类可以不存在抽象方法，但是一般不这么用，只是语法支持。

6.抽象类是不能创建对象的。

疑问：为什么抽象类不能创建对象？

因为抽象类是存在抽象方法的，如果让抽象类创建对象的话，那么使用抽象对象调用抽象方法是没有任何意义的。

7.抽象类是存在构造函数的，其构造函数是提供给子类对象初始化父类的属性的。

（3）抽象类的好处

强制要求子类一定要实现指定的方法。

常量的命名规范：全部字母大写，单词与单词之间使用下划线分隔。
abstract不能与以下关键字共同修饰一个方法：
   1. abstract不能与private共同修饰一个方法。
   2. abstract 不能与static共同修饰一个方法。
   3. abstract 不能与final共同修饰一个方法。

2.多态

一个对象具备多种形态。（父类的引用类型变量指向了子类的对象）

或者是接口的引用类型变量指向了接口实现类的对象

即继承关系下和实现关系下

多态的前提：必须存在继承或者实现关系

动物 a = new 狗() ;

多态要注意的细节：

1.多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。

2.多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。

3..多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。

4.多态情况下，不能访问子类特有的成员。

如果需要访问子类特有的成员，那么需要进行类型强制转换。

引用数据类型的转换

小数据类型->大数据类型自动类型转换

大数据类型->小数据类型强制类型转换

类型转换场景的问题：动物，鱼，老鼠。使用instanceof来判断是否是继承关系。

总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，只有在同名非静态函数时才是访问子类的。

编译看左边，运行不一定看右边。

编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。

多态的应用：

1.多态用于形式参数类型的时候，可以接收更多类型的数据。

需求1：定义一个函数，可以接收任意类型的图形对象，并且打印图形的面积与周长。

2.多态用于返回值类型的时候，可以返回更多类型的数据。

多态的好处：提高了代码的扩展性

实现关系下的多态：

接口变量 = new 接口实现类的对象

3.接口：

接口的定义格式：

interface 接口名{

成员变量

成员函数

}

接口的作用：程序解耦，定义约束规范，拓展功能

接口要注意的细节：

1.接口中成员变量都是敞亮，默认修饰符是public static final

2.接口中的方法全部是抽象的方法，默认的修饰符：public abstract

3.接口不能创建对象

4.接口是没有构造函数的

5.非抽象类通过implements实现接口的时候，必须要把接口中全部方法全部实现

接口与类之间的关系：实现关系

注意：一个类可以实现多个接口

接口与接口之间的关系：继承关系

一个接口是可以继承多个接口的

day02

1.内部类

定义：一个类定义在另一个类的内部，那么该类就称作为内部类。

内部类的class文件名：外部类$内部类。好处：便于区分该class文件是属于哪个外部类的。

内部类的类别：成员内部类，局部内部类

（1）成员内部类

访问方式：

方式一：在外部类提供一个方法创建内部类的对象进行访问

方式二：在其他类直接创建内部类对象

外部类.内部类对象名 = new 外部类().new 内部类()

内部类的应用场景：我们在描述一类事物A的时候，如果发现描述的事物A内部还存在另外一个比较复杂的事物B，而且这个比较复杂的事物B还需要访问A事物的属性等数据，那么这时候我们就可以使用内部类描述B事物。（在外部定义新事物的话，必须新建对象访问，这样比较麻烦）

内部类的好处：内部类可以直接访问外部类的所有成员。

内部类要注意的细节：

1.外部类与内部类存在同名的成员变量时，在内部类中默认情况下是访问内部类的成员变量。若想访问外部的成员变量：外部类.this.成员变量名来访问

2.私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能在其他类创建对象

3.成员内部类一旦出现静态成员，那么类也必须使用static修饰。

(静态成员变量是不依赖与对象存在而存在的，当.class文件被加载到内存中时，静态变量开始存在在内存中，但是如果静态变量在内部类中，只有外部类对象存在时内部类才存在，才可以访问内部类中的静态成员变量，此时违背了静态变量不依赖对象存在而存在的原则)

原因：静态数据是不依赖于对象存在而存在的。

如果是一个静态内部类，那么在其他类创建的格式：外部类.内部类变量名 = new 外部类.内部类()

//外部类
class Outer{

   //成员变量
   int x = 100; // Outer.class文件被加载到内存的时候存在内存中。静态的成员数据是不需要对象存在才能访问。
   //成员内部类
   static   class Inner{
       static   int i = 10;
       public void print(){
           System.out.println("这个是成员内部类的print方法！"+i);
       }
   }
   //在外部的方法中创建了内部类的对象，然后调用内部方法。
   public void instance(){
       Inner inner = new Inner();
       inner.print();
   }
}
//其他类
class Demo4
{
   public static void main(String[] args)
   {
       /*
       System.out.println(Outer.Inner.i);
       Outer outer = new Outer();
       outer.instance();
       Outer.Inner inner = new Outer().new Inner();
       inner.print();
       */
       Outer.Inner inner = new Outer.Inner();
       inner.print();
   }
}

（2）局部内部类

定义：在一个类的方法内部定义另外一个类，那么另外一个类就称作为局部内部类。

局部内部类要注意的细节：

1.如果局部内部类访问了一个局部变量，那么该局部变量必须使用final修饰。

*/
class Outer{
   String name= "外部类的name";
   public void test(){
       //局部变量
       final   int y =100; // y 什么时候从内存中消失？方法执行完毕之后y消失。
       //局部内部类
       class Inner{     /*
                       */
           int x = 10;

public void print(){
               System.out.println("这个是局部内部类的print方法.."+y);
           }
       }
       Inner inner = new Inner(); //这个inner对象什么时候消失？ Inner对象的生命周期比局部变量y的生命周期要长。
       inner.print();
   }
}
class Demo5
{
   public static void main(String[] args)
   {
       Outer outer = new Outer();
       outer.test();
   }
}

（3）匿名内部类

定义：没有类名的类就称作为匿名内部类。

匿名内部类的好处：简化书写。

匿名内部类使用前提：必须存在继承或者实现关系才能使用。

匿名内部类只是没有类名，其他的一切成员都是具备的。

匿名内部类无法调用子类特有的方法，只能用局部内部类去解决。

匿名内部类一般是用于实参。

abstract class Animal{

public abstract Animal run();

public abstract void sleep();
}

class Outer{

public void print(){
       //需求：在方法内部定义一个类继承Animal类，然后调用run方法与sleep()。

       /*
       //局部内部类
       class Dog extends Animal{

           public void run(){
               System.out.println("狗在跑..");
           }

public void sleep(){
               System.out.println("狗趴在睁开眼睛睡..");
           }
       }

       //创建对象
       Dog d = new Dog();
       d.run();
       d.sleep();
       */
       //匿名内部类：匿名内部类只是没有类名，其他的一概成员都是具备的。
       // 匿名内部类与Animal是继承的关系。目前是创建Animal子类的对象.
   Animal   a = new Animal(){ //多态

           //匿名内部的成员
           public Animal run(){
               System.out.println("狗在跑..");
               return this;
           }

           public void sleep(){
               System.out.println("狗趴在睁开眼睛睡..");
           }

//特有的方法
           public void bite(){
               System.out.println("狗在咬人..");
           }

       };

       a.bite();
       a.run();
       a.sleep();

   }
}
class Demo6
{
   public static void main(String[] args)
   {
       //System.out.println("Hello World!");

       Outer outer = new Outer();
       outer.print();
   }
}

day03

1.异常

我们的java程序也是会存在某些不正常的情况，这些不正常的情况我们统称为异常。

在java程序也会出现不正常的情况，java是面向对象的语言，任何的事物都可以使用类描述，那么这时候sun公司就使用而很多类来描述java程序中各种不正常的情况，而用于描述程序不正常的情况的类我们称作为异常类，很多异常堆积起来，就形成了java中的异常体系。

（1）Throwable

常用方法：

toString() //返回当前异常对象的完整类名+病态信息。完整类名=包名+类名

getMessage() //返回的是创建Throwable传入的字符串信息。

printStackTrace() //打印异常的栈信息

（2）Error 错误：一般是由于jvm或者是硬件引发的问题，所以我们一般不会通过代码去处理错误的。

（3）Exception 异常：是需要通过代码去处理的

如何区分错误与异常呢？

如果程序出现了不正常的信息，如果不正常的信息的类名是以Error结尾的，那么肯定是一个错误。

如果是以Exception结尾的，那么肯定就是一个异常。

jvm运行到a/b这个语句时，发现b为0，除数为零在我们现实生活中属于不正常的情况，JVM一旦发现了这种不正常的情况的时候，那么JVM就会马上创建一个对应的异常对象，并且会调用这个异常对象的printStackTrace的方法来处理。

2.异常的处理

方式一：捕获处理

捕获处理的格式：

　　　　try{

　　　　　　可能发生异常的代码

　　　　　　}catch(捕获的异常类型变量名){

　　　　　　处理异常的代码

　　　　　　}

　　捕获处理要注意的细节：

　　　　1.如果try块中代码出现了异常经过处理之后，那么try-catch块外面的代码可以正常执行。

　　　　2.如果try块中出现了异常的代码，那么在try块中出现在异常代码后面的代码是不会执行的，

　　　　3.一个try块后面是可以跟有多个catch块的，也就是一个tur块可以捕获多种异常的类型。

　　　　4.一个try块可以捕获多种异常的类型，但是捕获的异常类型必须从小到大进行捕获，否则编译报错。（因为从大到小捕获的话，后面的异常处理不会被触发）

　　疑问一：异常的处理感觉没什么用，因为都是输出一句话而已。

　　R:异常处理非常有用，只不过是由于我们目前所接触的知识点太过于局限而已。

　　疑问二：以后捕获处理的时候是否就是捕获Exception即可？

　　R：false ，因为我们在现实开发中遇到不同的异常类型的时候，往往会有不同的异常处理。所以要分开不同的异常类型进行处理。

方式二：抛出处理

主要用到两个关键字：throw thorws

　　抛出处理要注意的细节：

　　　　1.如果一个方法的内部抛出了一个编译时异常对象，那么必须要在方法上声明抛出。

　　　　2.如果调用了一个声明抛出编译时异常的方法，那么调用者必须处理异常。

　　　　3.如果一个方法内部抛出了一个异常对象，那么throw语句后面的代码都不会再执行。（一个方法遇到了throw关键字，该方法也会马上停止执行的。）

　　　　4.在一种情况下，只能抛出一种类型的异常对象，因为后面的语句不执行。

　　抛出处理的作用：

　　　　如果你需要通知到调用者，你代码出了问题，那么这时候就使用抛出处理。

　　　　如果代码是直接与用户打交道遇到了异常千万不要再抛，再抛的话就给了用户了。

　　　　这时候就应该使用捕获处理。

对比throw和throws两个关键字：

　　1.throw关键字是用于方法内部的，throws是用于方法声明上的。

　　2.throw关键字是用于方法内部抛出一个异常对象的，throws关键字是用于在方法声明上声明抛出异常类型的。

　　3.throw关键字后面只能有一个异常对象，throws一次可以声明抛出多种类型的异常。

day04

1.自定义异常类

　　sun公司提供了很多的异常类给我们用于描述程序中的不正常情况，但是sun给我提供的异常类还不足以描述我们现实生活中所有不正常情况，那么这时候我们就需要自定义异常类。

　　自定义异常类的步骤：自定义一个类继承Exception即可。（调用Exception的构造方法可以打印相关异常信息）

2.Exception 异常分类：

　　（1）运行时异常：如果一个方法内部抛出了一个运行时异常，那么方法上可以声明，也可以不声明；调用者可以处理，也可以不处理。

　　（2）编译时异常（非运行时异常，受检异常）：如果一个方法内部抛出了一个编译时异常对象，那么方法上必须要声明，而且调用者也必须要处理。

　　运行时异常：RuntimeException及其子类，都是运行时异常。

　　编译时异常：除了运行时异常就是编译时异常。

　　疑问：为什么java编译器会如此严格要求编译时异常，对运行时异常如此宽松？

　　因为运行时异常都是可以通过程序员良好的变成习惯去避免，所以java编译器没有严格要求处理运行时异常。而编译时异常无法通过代码来避免。

3.finally块

　　finally块的使用前提是必须要存在try块才能使用。

　　finally块的代码在任何情况下都会执行的，除了jvm退出的情况。

　　finally块非常适合做资源释放的工作，这样子可以保证资源文件在任何情况下都会释放。

　　try块的三种组合方式：

　　第一种：这种格式比较适合于有异常要处理，但是没有资源要释放。

　　　　　　try{

　　　　　　　　可能发生异常的代码

　　　　　　}

　　　　　　catch(捕获的异常类型变量名){

　　　　　　　　　　处理异常代码

　　　　　　　}

　　第二种：比较适用于既有异常要处理，又要释放资源的代码。

　　　　　　try{

　　　　　　　　可能发生异常的代码

　　　　　　}

　　　　　　catch(捕获的异常类型变量名){

　　　　　　　　　　处理异常代码

　　　　　　　}finally{

　　　　　　　　　　释放资源的代码

　　　　　　　　}

　　第三种：比较适用于内部抛出的是运行时异常，并且有资源要释放。

　　　　　　try{

　　　　　　　　可能发生异常的代码

　　　　　　}finally{

　　　　　　　　　　释放资源的代码

　　　　　　　　}

4.包

　　java的包就相当于Windows的文件夹

　　包的作用：　

　　　　1.解决类名重复产生冲突的问题。（类名重复时，生成同名的.class文件，会被覆盖）

　　　　2.便于软件版本的发布。

　　包名命名规范：包名全部小写

　　定义包的格式：

　　　　package 包名;

　　包语句要注意的事项：

　　　　1.package语句必须位于java文件夹中第一个语句

　　　 2.如果一个类加上了包语句，那么该类的完整类名就是：包名.类名

问题：每次编译的时候都需要自己创建一个文件夹，把对应的class文件存储到文件夹中。

　　javac -d . Demo1.java制定类文件的存放路径 java源文件

　　　　3.一个java文件只能有一个包语句。

有了包之后类与类的访问：

问题：有了包之后类与类的访问每次都必须要写上包名

解决方案：sun提供导包语句让我们解决该问题。

　　导包语句作用:简化书写。（误区：把一个类导入到内存中）

　　导包语句的格式：

　　　　推荐使用：import 包名.类名;（因为使用*通配符会导致结构不清晰）

　　　　import 包名.类名;　　（导入xx包中的某个类）

　　　　import 包名.*；

　　导包语句要注意的细节：

　　　　1.一个java文件中可以出现多个导包语句。

　　　　2.“*”是导包语句的通配符，可以匹配任何类名，只能匹配类名，不能匹配包名。。

　　　　3.import aa.*;是不会作用于aa包下面的子包

什么时候使用import语句?

　　相互访问的两个类不是在同一个包下面，这时候就需要使用导包语句。

　　java下的lang包是自动导入的，使用该包下的类时不需要使用导入语句。

day05

1.权限权限修饰符

含义：控制被修饰的类、属性、方法的范围可见性。

public（公共）

protected（受保护）

default（缺省。不写修饰符时默认此修饰符）

private（私有）

（从大到小）

注意：在不同包下面只有public与protected可以访问，而且protected必须是在继承关系下才能够访问。

2.jar包

作用：

打jar包：需要使用jdk的开发工具<jar.exe>

jar的用法：

使用格式：

　　jar cvf jar文件的名字 class文件或者是文件夹

　　eg:jar cvf qq.jar qq(文件夹名)

　　jar包中的.mf文件是清单文件，用于指定入口类，清单文件中写入口类的格式非常严格：

　　Main-Class: qq.Demo9

打jar包要注意的事项：

　　1.一个程序打完了jar之后，必须要在清单文件上指定入口类：Main-Class: 包名.类名。

　　2.jar包双击运行仅对于图形化界面的程序起作用，对控制台的程序不起作用。

jar文件的作用：

　　1.方便用户快速运行一个项目。

　　2.提供工具类给别人使用。

巴特西

java第二周学习日记

day01

1.抽象类

2.多态

day02

day03

day04

1.自定义异常类

2.Exception 异常分类：

3.finally块

4.包

day05

1.权限权限修饰符

2.jar包

最新文章

热门文章