Java初级笔记_面向对象3

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Java基础知识

一、Math类的随机数

类名调用静态方法：Math.random()

所在包：java.lang
类：Math
方法：public static double random():

java.lang包下的类是不用导包就可以直接使用的。

例：产生1-100之间的随机数：
int number = (int)(Math.random()*100)+1;

二、如何使用API

A:找到文档，打开文档。
B:点击左上角的显示变成隐藏，然后点击索引
C:明确自己找的是什么，类还是接口，什么类。比如Math
  明确后就在那个输入框里面输入Math，然后回车，再回车。
D:看这个类的结构
    java.lang 
       类 Math
      java.util 
       类 Scanner
   如果是java.lang包下的类，是可以直接使用的(如Math类)。否则，就需要导包才能使用(如Scanner类)
E:看看对这个类的说明。
F:看构造方法
     名称：字段 -- 成员变量 -- 属性。
    a:有构造方法，那么，就通过构造方法创建对象使用。
    b:没有构造方法，那么，这个类的成员一般都是静态。通过类名调用。
G:按照正常的操作使用方法。
     左边：
是否静态：如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。
是否有明确返回值：如果是void类型，就直接调用即可。否则，就可以输出或者赋值。
    右边：
看方法名：不要写错了。
看参数：看参数类型及个数

三、final关键字

(1)是一个关键字，最终修饰符，可以用于修饰类，成员变量，成员方法。
(2)特点：
          它修饰的类不能被继承。
        修饰变量，变量的值不能更改，成为了常量。
  -常量必须有值。
  -常量的值只能赋值一次。
  -引用类型常量可以更改其堆内存对象中的值。
内部类只能访问被外部类中被final修饰的局部变量。
它修饰的成员方法是不能被子类重写的。

四、多态

(1)同一个对象在不同时刻表现出来的不同状态。主要指的是方法的多态。
         另外的表达方式：针对同一个对象，编译期类型和运行期类型不一致。
(2)前提：
       A:有继承或者实现关系。
       B:有方法重写。
       C:有父类或者接口引用指向子类或者实现类对象。
(3)好处和弊端：
         A:好处
扩展性和维护性(是由继承和实现保证)。
       B:弊端
不能使用子类的特有功能。
(4)向上转型和向下转型
         A:向上转型
 把子类对象赋值给父类或者接口引用
       B:向下转型
 把父类或者父接口引用强制转换为子类
(5)多态中的使用成员特点
         A:成员变量
   编译运行都看左边
       B:成员方法
   编译看左边，运行看右边。

全部看使用的变量类型，只是在调用该方法时，检查子类是否重写。

(6)多态的体现形式
       A:具体类多态(几乎不用)
       B:抽象类多态
       C:接口多态

五、抽象类

(1)理解：

   多个具体的事物具备相同的方法声明，而方法体不同，我们就只抽取方法声明，然后定义到一个类中。而一个    没有方法体的方法是一个抽象方法，一个类中有抽象方法，该类必须定义为抽象类。

(2)定义

   包含抽象方法的类就是抽象类。而且一定是抽象类
   抽象类不一定包含抽象方法。
   类/抽象类不一定包含方法。
   抽象类可以有非抽象方法。

(3)格式：
   抽象类与抽象方法均需要使用abstract关键字。
   抽象方法格式：
修饰符 abstract 返回值类型   函数名(参数列表) ;
   抽象类格式：
修饰符 abstract class 类名{}
(4)抽象类的特点：
         A:抽象类本身无法实例化。

       B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

       C:抽象类通过多态的形式创建其子类实例对象。

       D:子类需要将抽象父类的抽象方法均覆盖才可以实例化，否则依然是抽象类。

       E:抽象类强制子类必须实现抽象方法。

(5)抽象类的几个小问题
         A:不能被实例化，要构造方法干啥?

          构造方法作用是初始化抽象类的成员变量，供子类使用
         B:一个类中没有抽象方法，居然定义抽象类，有什么意义?

          
         C:抽象关键字不能和哪些关键字共存
  private  抽象类需要继承，final修饰的无法继承
  final    抽象类的方法需要被覆盖，如果private修饰的话，子类无法访问
  static    静态的。抽象类抽象方法无方法体，调用无意义
(6)抽象类的成员：
          A:成员变量 有变量，也有常量
B:构造方法 有构造方法，用于子类访问父类数据的初始化
C:成员方法 有抽象方法，也有非抽象的方法

(7)注意
      抽象类包含构造方法，用来给属性赋值供子类实例对象使用

六、接口

(1)概述

   当一个抽象类中的方法都是抽象的时候，java就提供了一种更抽象的表达方式，叫接口。接口就是比抽象类更    为抽象的表现形式

(2)格式：
   定义接口：interface XX {}
   使用接口：class YY implements XX{}

(2)接口的成员特点：
          A:成员变量 是常量 默认修饰符 public static final(这些修饰符可以不写)
B:成员方法 抽象方法 默认修饰符 public abstract(这些修饰符可以不写)

(3)接口的特点：
          A:接口用interface定义
B:实现类实现接口用implements标识

        C:接口是对外暴露的规则。

D:接口是程序的功能扩展。

E:接口的出现降低耦合性。

F:java支持类同时实现多个接口。

G:java支持类在继承一个类的同时，实现多个接口。

H:接口与接口之间可以有继承关系。并且可以多继承。

I:接口不能被实例化。

J:接口是”like a”的关系

K:子类实现接口的时候，要么是抽象类，要么全部实现接口方法

(4)接口和类的关系

A:类与类的关系

    继承关系,只能单继承，可以多层继承。我继承了你，你继承了别的类

B:类与接口的关系

    实现关系，可以单实现，也可以多实现。

    还可以在继承一个类的同时，实现多个接口。

    class A extends B implements C，D

C:接口与接口的关系

    继承关系，可以单继承，也可以多继承。

(5)接口的思想特点(理解)

          A:对外暴露的规则(USB接口)

B:程序的扩展功能(多态)

C:降低程序的耦合性(多态)

D:让类可以多实现

(6)接口和抽象类的区别

       共性：都是不断抽取出来的抽象的内容。

A:成员特点

    抽象类：
成员变量： 可以变量，也可以常量
成员方法： 可以抽象，也可以非抽象
构造方法： 有
    接口：
成员变量： 只能是常量
成员方法： 只能是抽象
构造方法： 无

B:继承或者实现关系特点

    a:类与类的关系
继承关系,只能单继承，可以多层继承。

    b:类与接口的关系
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口。

    c:接口与接口的关系
继承关系，可以单继承，也可以多继承。

C:设计区别
抽象类中定义的是体系的共性内容。表达的是：is a的关系。
接口中定义的是体系的扩展功能。表达的是：like a的关系。

(7)如何实现一个继承体系

分析：由具体到抽象
实现：由抽象到具体

学习：抽象的内容,因为它定义的是共性内容。
使用：具体的内容,因为它才是具体实现，才具备更多的功能。

七、内部类

(1)把类定义在一个类的内部。

(2)特点：

     A:内部类可以直接使用外部类的成员，包括私有。

      B:外部类要使用内部类成员，必须创建对象使用。

(3)内部类的分类：

          局部内部类：定义在方法中的内部类

成员内部类：定义在类中方法外的内部类

(4)成员内部类

class Outer {
class Inner {

}
}

       普通修饰符修饰的时候：

 外部类名.内部类名 变量 = 外部类对象.内部类对象;

 Outer.Inner oi = new Outer().new Inner();
 class Outer {
static class Inner {
     void method(){}
}
}

        用静态修饰内部类时：

    外部类名.内部类名 变量 = 外部类名.内部类对象

    Outer.Inner oi = new Outer.Inner();

        用静态修饰内部类和方法时：

    Outer.Inner.method()

        成员内部类：

     private：为了数据的安全。

     static：为了方便调用。

(5)局部内部类

       A:带名字的局部内部类
class Outer {
public void method() {
final int a = 10;
class Inner {
public void show() {
System.out.println("show");
System.out.println(a);
}
}
Inner i = new Inner();
i.show();
}
}

        B:匿名内部类(掌握)

a:没有名字的局部内部类。其本质是一个对象。是通过多态来实现的。
b:前提：存在一个抽象类或者接口。
c:格式：
new 抽象类或者接口() {
重写父类方法;
};

本质：是一个继承了类或者实现了接口的子类匿名对象。

(6)面试题：
interface Inter {
public abstract void show();
}


class Outer {
//补齐代码
}

class Test {
public static void main(String[] args) {
Outer.method().show();
}
}

八、包

包的概述

  包就是将类分类管理，不同类的类放在不同的包下。其本质就是一个文件夹。

包的作用：让相同类名的类可以存在。为了组织代码。

cn.itcast.action   cn.itcast.service  cn.itcast.db

定义包：

package 包名.包名...;

带包的编译和运行

      A:方式一
    手动式
  a:javac编译代码
  b:手动建立包，把class扔进去
  c:java执行，带全路径

      B:方式二
     自动式
   a:通过javac编译自动生成包
javac -d . 文件名
   b:通过java运行class文件
java 包名.包名.class文件名不带扩展名

不同包下的类之间的访问

   权限够大才行。

   以后，我们所有定义的类都用public修饰。

面试题：
    在同一个java文件中，可不可以有多个类?

      可以。而我们知道类是可以用public修饰的,那么，可不可以多个类都用public修饰?不可以。并且，一般       的时候，如果有main方法也存在的时候，都是public修饰带main那个类。文件名必须和该public修饰的       类名一致。


导包
   (1)如果多次使用一个多级包的类，每次带全路径太麻烦，我们就考虑使用导包。

   (2)导包的格式：

import 包名.包名...;

注意：
在同一个包下如果有多个类被使用，可以使用通配符*来导入，但是不建议。
推荐：使用谁导入谁。
   (3)面试题：
package，import，class出现的位置?
package > import > class

九、权限修饰符

(1)用于保证在不同的情况下可以使用
(2)使用如下
本类 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y

常见的组合规则：

权限修饰符+abstract/final/static+...

我们到底怎么用(开发的时候一般都这么做)：

类：
public class Demo {

}


成员变量：
变量：private String name;  加上相应的getter和setter
常量：public static final int X = 10;


构造方法：
不让外界创建：private Demo(){}
大部分：public Demo(){}


成员方法：
不让外界用：private void show(){}
大部分：public void method(){}
抽象方法：public abstract void function();

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------