我的java日记(面向对象下)

不断为自己的目标奋斗,自己的未来只能由自己决定.加油!!!

一:
1:在API中如果该类没有构造方法
 (1):所有的变量和方法都是静态的,可以直接用类名进行调用.
 (2):它有一个静态方法返回它的对象

2:只有java.lang下的类不用导包,java.lang.Math中也有random方法
3:java.util.Random类的构造方法:
 Random():创建一个新的随机数.
 Random(long seed):根据seed创建一个随机数,此随机数是固定的(每次随机数都是一样的).

4:Scanner类的使用:
 可以获取从键盘输入的数据.
二:继承
1:多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
继承的好处:
 (1):继承的出现,提高了代码的复用性
(2):继承的出现,让类与类之间产生了关系,这个关系的出现是多态的前提.

2:多个类可以称为子类或者派生类，单独这个类称为父类,基类或者超类。
3:子类可以直接访问父类中的非私有的属性和方法。被private修饰的属性和方法不能被继承.
4:通过 extends 关键字让类与类之间产生继承关系。
格式:class Son extends Father{}

5:继承的特点:
 (1):java只支持单继承,不支持多继承.(也就是说一个子类只能有一个父类)
  假如可以多继承,那么就会造成调用不确定问题.也就是产生了安全隐患.
(2):java支持多层继承.
 class A{}
 class B extends A{}
 class C extends B{}
 6:如何判断两个类是否有继承关系呢?
 
7:注意:
 不要仅为了获取其他类中某个功能而去继承.

8:继承中构造方法间的关系:
  在子类实例化过程,子类创建对象时,会先去创建父类的对象.默认是去调用父类的无参构造.
 子类中所有的构造函数默认都会访问父类中无参构造方法(每创建一个子类对象,就会自动调用一次父类的无参构造,如果子类手动调用有参构造,就不会再调用无参构造了)
 因为子类每一个构造函数的第一行都有一条默认的语句super();
 子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
 当父类中没有无参构造时，子类的构造方法必须通过this或者super语句指定要访问的构造方法。
不管是java提供给我们使用的类,还是我们自定义的类,都是Object类的子类.
9:super关键字 (代表父类空间的引用)
 super和this的用法相像
 this代表本类对象的引用
 super代表父类的内存空间的标识。
 当子父类出现同名成员时，可以用super进行区分
子类要调用父类构造函数时，可以使用super语句

 10:方法复写:
 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
 父类中的私有方法不可以被复写。
 在子类复写方法中，继续使用被复写的方法可以通过super.函数名获取(即父类中的方法)。
 覆盖注意事项：
 覆盖时，子类方法权限一定要大于等于父类方法权限
 静态只能覆盖静态。
 覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

11: 子父类中的成员变量的的关系:
(1) 不同名的非私有的可以直接继承使用.
(2) 同名的成员使用:
子类方法中使用一个变量
首先在方法中找局部变量,有则使用
否则,接着在本类中找,有则使用
否则,最后在父类中找,有则使用
否则,报错.

 12:this()和super()的区别:
this:代表本类对象的引用
super:代表的是父类的存储空间。注意：这里不是一个具体的对象。

this可以用于区分局部变量和成员变量同名的情况。
super可以用于区分子父类中成员变量同名的情况。

this.可以调用本类的成员
super.可以调用父类的成员

this(可能有参数):用于构造方法中调用本类的其他构造方法。
super(可能有参数):用于构造方法中调用本类的父类的构造方法。

13:重载和重写
 重载:在同一个类中,方法名相同,参数列表不同.
 重写(覆盖):不在同一个类中(字符类),方法的声明相同(返回类型,方法名,参数列表都要相同.)

 权限修饰:子类要求大于等于父类的访问权限.
14:final关键字
 final可以修饰类，方法，变量。
 final修饰的类不可以被继承。(就成了最底层的类)
 final修饰的方法不可以被复写
 final修饰的变量是一个常量。只能被赋值一次。
 内部类只能访问被final修饰的局部变量。

三:抽象类(用于多个类的共性)
1:抽象定义：
 抽象就是从多个类中将方法名相同而方法体不同的方法抽取出来，本质的内容抽取出来。
 例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。
2:抽象类：
 Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，
 包含抽象方法的类就是抽象类。
3:抽象方法的由来：
 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，
 并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
 例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，
 但是并不明确吼叫的细节。
4:抽象类的特点:
 (1)抽象类和抽象方法必须用abstract关键字来修饰。
 (2)抽象方法只有方法声明，没有方法体，定义在抽象类中。
 (3)抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类.
 (4)抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
  抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。
  例如：犬科是一个抽象的概念，真正存在的是狼和狗。
  而且抽象类即使创建了对象，调用抽象方法也没有意义。
 (5):抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，
     否则该子类也要定义为抽象类。
 抽象类的定义格式:
  abstract class 类名{}
 抽象方法的定义格式:
  格式：修饰符 abstract 返回值类型   函数名(参数列表) ;

5:抽象类中有哪些东西?
 成员变量:抽象类中可以有成员变量也可以有常量.
 方法:抽象类中既可以有抽象方法,也可以有非抽象方法.
 构造方法:抽象类中有构造方法.虽然不能创建对象,但是供子类实例化使用的.
抽象关键字abstract不可以和哪些关键字共存?
 private:私有内容子类继承不到,所以,不能重写.
  但是,abstract修饰的方法,要求被重写,两者冲突.
 final:final修饰的方法不能被重写,而abstract修饰的方法,要求被重写,两者冲突.
 static: 假如一个抽象方法可以用static修饰,那么这个方法可以被类名直接调用,但是抽象方法没有方法体的,
  这样调用无意义.
例:
/*
学员示例
具体事务：基本班学员，就业班学员
共性：姓名，学习，休假
*/

abstract class Student     //抽象类
{
 String name;
 String sex;
 abstract void study();    //抽象方法
 abstract void holiday(); //抽象方法
 Student(String name,String sex){  //构造方法
  this.name=name;
  this.sex=sex;
 }
}
class BaseStudent extends Student         //定义基础班学员类 继承抽象类
{
 public BaseStudent(){}
 public BaseStudent(String name,String sex){
  super(name,sex);                //使用super关键字
 }
 public void study(){                 //复写抽象方法
  System.out.println(name+","+sex+",是基本班学员");
 }
 public void holiday(){                //复写抽象方法
  System.out.println("喜欢休假");
 }
}
class WorkStudent extends Student                 //定义就业班学员类,继承抽象类
{ public WorkStudnet(){}
 public WorkStudent(String name,String sex){
  super(name,sex);
 }
 public void study(){
  System.out.println(name+","+sex+",是就业班学员");
 }
 public void holiday(){
  System.out.println("不喜欢休假");
 }
}
class StudentDemo
{
 public static void main(String[] args)
 {
  
  BaseStudent bs=new BaseStudent("李德华","男");//实例化BaseStudent类
  bs.study();   //调用方法
  bs.holiday();
  WorkStudent ws=new WorkStudent("蔡依林","女");
  ws.study();
  ws.holiday();
 }
}

四:接口:(用于类的扩展功能)
当一个类中的方法都是抽象方法的时候,java提供了另外一种表示方法,叫接口
1:格式：interface 接口名 {}
2:接口中的数据特点:
 接口中的成员修饰符是固定的。
 成员常量：public static final(接口中没有变量,推荐自己手动给出权限)
  即使写:int num=20;也是默认前面加上public static final,即常量.
 成员方法：public abstract(默认权限是public)
 发现接口中的成员都是public的。
 接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。
 接口中没有构造方法.
 一般接口的实现类名是:接口名+Impl

3:类与类的关系:继承关系.是单继承,但是可以多层继承.用extends关键字.
  类与接口的关系:实现关系,是多实现,并且类可以在继承一个类的基础上实现多个接口.用implements关键字.
  接口与接口的关系:继承关系,是多继承,用extends关键字

4:接口的特点:
 (1)接口是对外暴露的规则。例如:CPU的插槽
 (2)接口是程序的功能扩展。预留多个USB接口,插座.
 (3)接口的出现降低耦合性。
  耦合:类与类之间的关系.(比如依赖关系)
  内聚:类完成功能的能力.
  编程规范:低耦合,高内聚.
 (4)接口可以用来多实现。
 (5)类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
 (6)接口与接口之间可以有继承关系。
5:接口和抽象类的区别:
 (1):抽象类只能被单继承,接口可以多实现
 (2):抽象类中的数据特点:
  成员变量:可以使变量,也可以是常量
  成员方法:可以是抽象方法,也可以是非抽象方法.
  构造方法:有构造方法.
     接口中的数据特点:
  成员变量:是常量.都是默认修饰public static final
  成员方法:都是抽象方法,都是默认修饰public abstract
  无构造方法
 (3)接口的出现避免了多继承的局限性.
 (4)抽象类中定义的是体系中的共性功能.
    接口中定义的是体系中的扩展功能.
 (5)抽象类被继承是"is a"关系:xx是yy的一种.
    接口被实现是"like a"关系:xx像yy的一种.

6:共性:都是不断抽取出来的抽象概念.

五:多态:
多种形态,对象在不同时刻所代表的多种状态.
1:前提:
 (1)必须存在继承或者实现关系
 (2)有方法的重写
 (3)应该有父类引用指向子类对象.

2:定义：某一类事物的多种存在形态。
 例：动物中猫，狗。
 猫这个对象对应的类型是猫类型
 猫 x = new 猫();
 同时猫也是动物中的一种，也可以把猫称为动物。
 动物  y = new 猫();
 动物是猫和狗具体事物中抽取出来的父类型。
 父类型引用指向了子类对象。

3:程序中体现：
 父类或者接口的引用指向或者接收自己的子类对象。
4:好处和作用：
 多态的存在提高了程序的扩展性和后期可维护性

(向上转型)
5:多态的特点:父类引用对象时只能调用父类中有的,不能调用子类中所特有的.
 (1)成员方法：
  编译时:(看左边)要查看引用变量所属的类中是否有所调用的成员。
  在运行时:(看右边)要查看对象所属的类中是否有所调用的成员。
 (2)成员变量：只看引用变量所属的类。
  编译看左边,运行看左边.
 (3)静态方法:
  编译看左边,运行看左边.

(向下转型)
6:当有一个父类引用指向子类对象时,如果你想访问子类中特有的方法
可以把父类引用强制转换成子类对象.(所以向下转型要在向上转型的基础上.)
例:
/*
动物都有吃食物的方法，而他们吃的事物不一样；动物都爱玩游戏，但是他们玩的游戏不一样。
比如说狗吃骨头，喜欢跑步；猫吃老鼠，喜欢捉迷藏；请用抽象类或者接口来做此题。
并在测试类中进行测试。
*/
interface Animal  //定义接口
{
 public abstract void eat();
 public abstract void play();
}
class Dog implements Animal
{
 public void eat(){
  System.out.println("狗爱啃骨头!");
 }
 public void play(){
  System.out.println("狗爱玩球");
 }
 public void color(){
  System.out.println("这条狗是黑色的!");
 }
}
class Cat implements Animal
{
 public void eat(){
  System.out.println("猫喜欢吃鱼");
 }
 public void play(){
  System.out.println("猫喜欢爬树");
 }
 public void sleep(){
  System.out.println("猫爱睡觉");
 }
}
class DuoTaiDemo
{
 public static void main(String[] args)
 {
  Animal a=new Dog();  //向上转型
  a.eat();
  a.play();
  Dog d=(Dog)a;  //向下转向
  d.color();
  a=new Cat();  //向上转向
  a.eat();
  a.play();
  if(a instanceof Dog){ //判断对象a是否是Dog的对象
   d=(Dog)a;
   d.color();
  }else if(a instanceof Cat){
   Cat c=(Cat)a;
   c.sleep();
  }
  
  
 }
}

7:多态的思想:指挥同一批对象做事情.例:带兵打仗.

instanceof:用于判断某个对象是否是某个类的对象.
 格式:对象名 instanceof 类名;如果是则返回true,如果不是则返回false

六：Object类(重点)
 (1)是所有类的根类，超类。
    java中提供的类以及我们自定义的类都直接或者间接的继承自Object类。
 (2)Object类中的方法
  A:void finalize()
    当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
  B:Class getClass()
    获取对象的字节码文件的描述类，后面再讲反射的时候还会在说这个类。
    String name = s.getClass().getName();
  C:int hashCode()
    获取对象的哈希值。其实就是对象的内存地址值十进制表示
  D:String toString()
    返回对象的字符串表示。
    表示格式：
    getClass().getName()+"@"+Integer.toHexString(hashCode());

    一般我们输出对象名的时候，其实底层调用的就是该对象的toString()方法。
    这种返回没有意义，所以，我们会重写这个方法，显示类的成员变量信息。
  E:boolean equals(Object obj)
    用于比较两个对象的地址值是否相同。
    我们获取对象后，比较它的地址值意义不大。所以也会对这个方法进行重写。
    重写要完成什么功能，是根据需求定的。

    假如：有一个学生类，其中有一个int类型的age成员变量。我们需要用此方法
          实现比较学生的年龄是否相同。

    public boolean equals(Object obj) //向上转型
    {
   //为了提高效率
   if(this == obj)
   {
    return true;
   }

   //为了提高程序的健壮性
   if(!(obj instanceof Student))
   {
    return false;
   }

   //向下转型
   Student s = (Student) obj;
   return this.age == s.age;
    }
 (3)==和equals的用法。
  A:==怎么用？
   **可以用于比较基本数据类型，比较的就是基本数据类型的值是否相等。
   **可以用于比较引用数据类型，比较的是对象的地址值是否相等。
  B:equals怎么用？
   equals只能用于比较引用数据类型的。
   **Object提供的equals是用于比较对象地址值是否相同。
   **自定义类中，如果重写了equals方法，那么就是按照你自己的需求来比较的。
  
   String str = new String("hello");
   String str2 = new String("hello");

   sop(str.equals(str2)); //true
 (4)练习：
  有一个学生类(姓名，年龄)。
  需要提供一个功能：这个功能是用于比较学生的姓名和年龄是否同时相同。
                    如果同时相同，那么，我就认为这是同一个学生。返回true。
class Student
{
 private String name;
 private int age;

 public Student(){}

 public Student(String name,int age)
 {
  this.name = name;
  this.age = age;
 }

 public boolean equals(Object obj)
 {
  if(this == obj)
  {
   return true;
  }

  if(!(obj instanceof Student))
  {
   return false;
  }

  Student s = (Student) obj;

  return (this.age == s.age) && (this.name.equals(s.name));
 }
}

class EqualsDemo
{
 public static void main(String[] args)
 {
  Student s1 = new Student("梅艳芳",25);
  Student s2 = new Student("梅艳芳",25);

  System.out.println(s1.equals(s2));
 } 
}

七：package关键字
 (1)包：其实就是文件夹。用于区分不同包下相同的类名。
 (2)好处：
  A：对类文件进行分类管理。
  B：给类提供了多层命名空间
   aaa.Demo
   bbb.Demo
  C：写在程序文件的第一行。
  D：包也是一种封装形式。
 (3)包的关键字是：package
  格式：
   单层包
    package 包名;
   多层包
   package 包1.包2.包...;
 (4)带包的类如何运行呢？
  A:首先编译这个类文件
    其次，手动创建包名，把class文件放入包中。
    最后，访问格式
    包名.类名
  B:java提供了另外一个格式
   javac -d . 类文件

   -d：表示后面跟的是目录
   . ：表示的是当前目录

   编译：javac -d . PackageDemo.java
   执行：java cn.itcast.PackageDemo 
 (5)不同包下的类是如何访问的？
  A:被访问的包中的类权限必须是public的。
  B:类中的成员权限：public或者protected(protected 这个时候，
    PackageDemo2要是Tool的子类才行)
 (6)练习：
  如果访问写在包中的类。

3：import关键字
 (1)导入包的关键字
 (2)格式：
  import 包名;
 (3)注意：
  A:一个程序文件中只有一个package，可以有多个import。
  B:用来导包中的类，不导入包中的包。
  C:通常写import  mypack.Demo;
    而不写import mypack.*;为什么？

    明确自己使用的类。
 (4)关键字的顺序
  类，包，导包这些关键的顺序。

  包 -- >  到包 -- > 类

  package xxx.yyy.zzz;

  import java.util.Scanner;

  class Demo
  {
  
  }

八：
1:权限修饰符
  本类中 同一个包中 不同包中的子类中 不同包中
private  OK 
默认  OK Ok  
protected OK Ok     OK
public  OK Ok     OK      Ok

2：不同修饰符可以修饰哪些内容
  类 构造方法 成员变量 成员方法  
private   OK  OK  OK
默认  Ok Ok  Ok  OK
protected  OK  OK  Ok
public          Ok Ok  OK  OK
static     OK  Ok
final  Ok   OK  OK
abstract Ok     OK

一般格式：
 成员变量：
 权限修饰符+static/final+数据类型+成员变量名
 public static final int NUM = 10;
 
 成员方法：
 权限修饰符+static/final/abstract+返回类型+方法名

权限修饰符只能有一个，如果没写就是默认权限。
九：内部类(次重点)
 (1)把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。
 (2)访问形式：
  A:内部类可以直接访问外部类中的成员。
  B:外部类要想访问内部类的成员，必须创建对象访问。
 (3)什么使用时候内部类呢？
  假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，
  需要创建对象访问，这个时候，就可以把A类定义为B类的内部类。
 (4)内部类的位置
  A:成员位置
   **可以被private修饰(Body，Heart)
    内部类如果被私有化则不能直接被其他类访问,只能通过外部类来调用内部类.
    即:先在外部类中实例化内部类,在通过调用外部类的方法来调用内部类
   **可以被static修饰。(它访问的外部类的成员必须是静态的)

  class Outer
  {
   int num = 10;

   class Inner
   {
    public void show()
    {
     sop(num);
    }
   } 

   public void method()
   {
   (1) Inner i = new Inner();    //在外部类方法中实例化内部类
    i.show();
   }
  }

  注意：
   如果测试类中想直接访问内部类，格式如下
        (2)外部类名.内部类名 对象名 = 外部类对象.内部类对象;
   Outer.Inner oi = new Outer().new Inner();

   假如内部类使用static修饰的，在测试类中使用，格式如下
        (3)外部类名.内部类名 对象名 = new 外部类.内部类();
          Outer.Inner oi = new Outer.Inner();
  
  B:局部位置
   **可以直接访问外部类中的成员，也可以直接访问局部成员，但是
     局部成员要用final修饰。
  
  class Outer
  {
   int num = 10;

   public void method()
   {
    int num2 = 20;
    final int num3 = 30;

    class Inner     //局部内部类
    {
     public void show()
     {
      sop(num3);
     }
    }

    Inner i = new Inner();   //在方法中实例化内部类
    i.show();
   }
  }

  注意：
   局部内部类不能用private和static修饰。
 (5)通过class文件我们就可以区分是否带有内部类，以及内部类的位置
  Outer$Inner:成员内部类
  Outer$1Inner:局部内部类
 (6)匿名内部类(局部内部类的简写) (重点)
  前提：继承一个类或者实现一个接口

  格式：
   new 父类名或者接口名()
   {
    重写父类方法或者实现接口中的方法。
    也可以自定义其他方法。
   };
 (7)什么情况下，适合使用匿名内部类。
  通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
  增强阅读性。

  举例：
  interface Inter
  {
   public abstract void show();
  }

  class Outer
  {
   public void method()
   {
    new Inter()
    {
     public void show()
     {
      sop("show");
     }
    };

    //如何调用方法呢？
    new Inter()
    {
     public void show()
     {
      sop("show");
     }
    }.show();

    //或者
    Inter i = new Inter()
    {
     public void show()
     {
      sop("show");
     }
    };
    i.show();
   }
  }
 (7)面试题
  interface Inter
  {
   void show();
  }

  class Outer
  {
   static Inter method(){
    Inter i=new Inter(){
     public void show(){
      System.out.println("周传雄");
     }
    };
   return i;
   }
  }

  class Test
  {
   public static void main(String[] args)
   {
    Outer.method().show(); //自己名字的拼音
   }
  }