1.多态

  1. 多态参数：参数定义成父类类型，就可以传任意子类类型进去
  2. 向上转型

a) 语法: 父类类型 引用名 = new 子类类型();
b) 父类引用指向子类对象
c) 编译类型看左边，运行类型看右边
d) 可以调用父类中的所有成员(受访问修饰符影响)
e) 调用的时候，子类有就用子类的成员，子类没有就找父类(就近原则)
f) 不能调用子类中特有成员

  1. 注意事项
    a) 多态的前提: 两个对象(类)存在继承关系
    b) 属性的值看编译类型（即传入对象people 只会在people.java里面去寻找里面的属性，方法才会向下寻找。）
    c) 只要编译能通过，方法都是看运行类型，属性看编译类型
    d) instanceOf 比较操作符，用于判断对象的运行类型是否为xx类型或xx类型的子类型
    e) 要调用子类中特有成员，还需要向下转型(其实就是强转)，转回实际类型，瞎转会报错 ```java package com.dudu.app; public class people { public String call(){
    1.  System.out.println("people");
    2.  return "people";}}
    //======================people.java======================================= package com.dudu.app; public class test extends people { public String call(){
    1.  System.out.println("test");
    2.  return "test";}}
    //======================students.java=======================================

import com.dudu.app.people; import com.dudu.app.students; public class Hello { public static void main(String[] args){ people people = new people(); people students = new students();//用父类接收子类创建出来的对象 call1(people);//people call1(students);//students} public static String call1(people p){ //传入的是people父类，students是继承people父类 / students s=(students)p; 这句代码，就是把传入的p对象，强制向下转型，转换成他的子类，students /

  1.    p.call();
  2.     return "people";}}

// instanceof 比较操作符，用于判断对象的运行类型是否为xx类型或xx类型的子类型 /boolean b = students instanceof people; boolean b1 = students instanceof students; boolean b2 = students instanceof test; System.out.println(b+ “ “ + b1+ “ “+b2 +” “); / //true true false 

  2. 4. 多态数组
  3. ```java
  4. import com.dudu.app.people;
  5. import com.dudu.app.students;
  6. import com.dudu.app.test;
  7. public class Hello {
  8.     public static void main(String[] args){
  9.         people people1 = new people();
  10.         people students = new students();
  11.         test test1 = new test();
  12.         people[] p1=  new people[]{people1,students,test1};
  13.         for (int i = 0; i < p1.length; i++) {
  14.             p1[i].call();
  15.         }
  16.     }
  17. }
  1. 动态绑定机制
  • 当调用对象方法的时候，始终会从子类开始寻找，子类里面没有的话，再找父类里面的。
  • 当调用对象属性时，没有动态绑定机制，就近原则。

    2.equals

  1. ==
    既可以判断基本类型，也可以判断引用类型
    基本类型判断值，引用类型判断地址
  2. equals
  • equals 是Object类中的方法，只能判断引用类型 （比较内存地址）
  • 默认判断的是地址是否相等
  • 子类一般会重写equals方法，用于判断内容是否相等，比如Integer、String

    3.toString

  1. toString方法
    public String tostring() {
    return getClass().getName() + “@” + Integer.toHexString(hashCode());}
    a) 默认返回: 全类名 + @ + 哈希值的十六进制
    b) 子类往往重写toString方法，用于返回对象的属性信息
    c) 当直接输出一个对象时，toString方法会被默认的调用

    4.final

  2. final应用场景
    a) 不希望类被继承
    c) 不希望类的属性值被修改(常量)
    b) 不希望父类的方法被子类覆盖/重写(override)
    d) 不希望局部变量(参数)被修改(局部常量)

  3. final修饰实例属性，可以在定义时、构造器中、普通代码块中赋初值
  4. final修饰静态属性，可以在定义时 、静态代码块中赋初值

  5. final注意事项
    a) final修饰属性，必须赋值，并且不能再次修改
    b) final可以修饰类、属性、方法和局部变量(参数)，不能修饰构造器
    c) 包装类(Integer、Double、Float、Boolean)和String都是final类
    d) final修饰类，不能被继承，但是可以实例化对象(如何不让实例化)
    e) final和static搭配使用，不会加载类

    5.抽象类

  6. abstract只能修饰类和方法
    用abstract关键字来修饰一个类时,这个类就叫抽象类
    用abstract关键字来修饰一个方法时,这个方法就是抽象方法

  7. 抽象类注意事项
    抽象类可以有任意成员，可以被继承，可以没有抽象方法
    有了抽象方法，则这个类必须声明为abstract
    抽象类不能被实例化
    继承了抽象类，则必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
    抽象方法不能使用private、final和static来修饰 

    1. package com.dudu.app;
    2. public abstract class people  {
    3. public abstract  void job();
    4. // public abstract  void test1();
    5. /*如果这里创建了一个test1的抽象方法，那么必须在这个类的子类里面具体实现这个方法，不然就会报错的；
    6. 如果没有实现test1方法，那么可以选择把该子类也设置成抽象类，因为抽象类可以继承。但是，一旦设置成了抽象类，
    7. 这个类就不能被实例化了。 
    8. */
    9. public void sum(){
    10.     System.out.println("开始计算....");
    11.     job();
    12.     System.out.println("结束计算....");
    13. }
    14. }
    15. //======================people.java=======================================
    16. package com.dudu.app;
    17. public class students extends people{
    18. public void job(){
    19.     int result=0;
    20.     for (int i = 0; i <=100; i++) {
    21.         if( i%2==0){            result+=i;};}
    22.     System.out.println("偶数计算结果："+result);
    23. }
    24. }
    25. //======================students.java=======================================
    26. package com.dudu.app;
    27. public  class test extends people{
    28. public void job() {
    29.     int result = 0;
    30.     for (int i = 0; i <= 100; i++) {
    31.         result += i;}
    32.     System.out.println("总数计算结果：" + result);
    33. }}
    34. //======================test.java=======================================
    35. import com.dudu.app.people;
    36. import com.dudu.app.students;
    37. import com.dudu.app.test;
    38. public class Hello {
    39. public static void main(String[] args){
    40.     people students = new students();
    41.     people test = new test();
    42.     students.job();//偶数计算结果：2550
    43.     test.job();//总数计算结果：5050
    44. }
    45. }
    46. //======================Hello.java=======================================

    6.接口

  8. 什么是接口
    电脑USB 手机 鼠标 键盘 U盘
    协议

  9. 基本语法
    interface 接口名{
    //属性
    //方法
    }
    class 类名 implements 接口名{
    必须实现接口的所有抽象方法
    }
  10. 注意事项
    a) 接口不能被实例化
    b) 接口的修饰符只能是public和默认，这点和类的修饰符是一样的
    c) 一个接口不能继承其它的类,但是可以继承多个别的接口
    d) 接口中的方法都是public方法，抽象方法可以不用abstract修饰
    e) 一个普通类实现接口,就必须将该接口的所有方法都实现
    f) 抽象类实现接口，可以不用实现接口的方法
    g) 一个类同时可以实现多个接口
    h) 接口中的属性都是public static final修饰符
    int a = 1; 实际上是 public static final int a = 1;(必须初始化)
    接口中属性的访问形式: 接口名.属性名

  11. 接口的多态特性
    多态参数、多态数组 

    1. package com.dudu.app;
    2. public interface USB {
    3. public void keyboard();
    4. public void mouse();
    5. }
    6. //======================USB.java=======================================接口创建
    7. package com.dudu.app;
    8. public class students implements USB{
    9.     public void keyboard(){
    10.         System.out.println("学生接口keyboard");
    11.     };
    12.     public void mouse(){
    13.         System.out.println("学生接口mouse");
    14.     };
    15. }
    16. //======================students.java=======================================继承与实现
    17. package com.dudu.app;
    18. public  class test implements USB{
    19. public void keyboard(){
    20.     System.out.println("test接口keyboard");
    21. };
    22. public void mouse(){
    23.     System.out.println("test接口mouse");
    24. };
    25. }
    26. //======================test.java=======================================继承与实现
    27. import com.dudu.app.USB;
    28. import com.dudu.app.people;
    29. import com.dudu.app.students;
    30. import com.dudu.app.test;
    31. public class Hello {
    32. public static void main(String[] args){
    33.  USB[] A=new USB[]{new students(),new test()};//并不是实例化USB，只是用了一个USB数组接收子类的实例化对象；
    34.  computer.work(new students());
    35.  computer.work(new test());
    36. }}
    37. class computer{
    38. public static void work(USB args){//students和test两者 implements USB 相当于是USB的子类了。
    39.                                   //传入他们两个的父类也就没问题了；
    40.     args.mouse();
    41.     args.keyboard();
    42. }
    43. }
    44. //======================Hello.java=======================================调用

    8.内部类

  12. 类的五大成员：属性 方法 构造器 代码块 内部类
    内部类本质上就是一个类，类相关的功能都有

  13. 内部类的分类
    定义在外部类的成员位置上:
    a)成员内部类（没用static修饰)
    b)静态内部类 (使用static修饰)

定义在外部类局部位置上(比如方法内):
a)局部内部类(有类名)
b)匿名内部类(没有类名)

  1. public class Hello {
  2.  public static void main(String[] args){
  3.      outclass outclass1111 = new outclass();
  4.      outclass.innerclass innerclass111= outclass1111.test();
  5.      System.out.println(innerclass111.A);
  6.      //System.out.println(outclass1111.getClass().getName());获取外部类的类名
  9.  }
  10. }
  12. class outclass{
  13.     public static String CC="TTTT";
  14.     public innerclass test(){
  15.         innerclass innerclass1111 = new innerclass("Python");
  16.         return innerclass1111;
  17.     }
  18.     class innerclass{//内部类
  19.        public String A="JAVA";
  20.         public innerclass(String a) {
  21.             A = a;
  22.             System.out.println( A+"    内部类调用");
  23.             System.out.println(CC);
  24.         }
  25.         //内部类不能设置静态属性static，但是可以访问外部类的static修饰的
  26.     }
  27. }
  28. //======================Hello.java=======================================
  29. //写一个test方法，里面实例内部类，然后在再main函数里现事例外部类，再调用内部类

9.成员内部类

  1. 定义在外部类的成员位置上, 并且没有static修饰

  2. 注意事项
    a) 可以直接访问外部类的所有成员, 包含私有的、静态的
    b) 可以添加任意访问修饰符去修饰成员内部类, 因为它相当于一个成员
    c) 成员内部类不能定义静态成员
    d) 作用域与其他成员一样
    e) 外部类可以访问成员内部类
    f) 外部其他类可以访问成员内部类
    new Test().new Inner();
    在外部类里定义一个方法，返回内部类的对象
    f) 外部类和内部类成员重名，遵循就近原则。想访问外部类的成员，可以使用(外部类名.this.成员)去访问

    10.静态内部类

  3. static修饰；

  4. 静态方法能调用静态方法，不能调用实例方法；

  5. 可以直接类名.属性 / 类名.方法 调用

    11.局部内部类

  6. 局部内部类概念
    定义在外部类的局部位置上, 比如方法中，并且有类名

  7. 注意事项
    a) 可以直接访问外部类的所有成员, 包含私有的、静态的
    b) 如果定义在静态方法中，则只能访问外部类的静态成员
    c) 局部内部类不能定义静态成员
    d) 不能添加访问修饰符，可以使用final修饰，因为它就是一个局部变量
    e) 作用域仅在定义它的代码块中，与局部变量一致
    f) 外部类和内部类成员重名，遵循就近原则。想访问外部类的成员，可以使用(外部类名.this.成员)去访问(在实例方法中)。如果是定义在静态方法中，可以使用(外部类名.静态成员名)去访问
    g) 外部类不能访问局部内部类

    12.匿名内部类

  8. 匿名内部类的语法
    基于接口的匿名内部类
    基于类(抽象类)的匿名内部类

  9. 注意事项
    a) 可以直接访问外部类的所有成员(受访问修饰符影响)，包括静态的
    b) 匿名内部类不能定义静态成员
    c) 匿名内部类只能创建一个实例
    d) 匿名内部类实际上也是有名字的，系统自动分配
    e) 外部类和内部类成员重名，遵循就近原则。想访问外部类的成员，如果是静态成员，可以使用(外部类名.静态成员名)去访问，如果是实例成员，只有当匿名内部类处于外部类里面的时候，才能使用(外部类名.this.成员名)去访问
    f) 外部类不能访问匿名内部类
    g) 匿名内部类在定义的同时直接创建对象，并当作实参传递，代码简洁 ```java package com.dudu.app; public interface USB { public void keyboard(); public void mouse(); } //======================USB.java=======================================接口 package com.dudu.app; public abstract class USB2 { public abstract void keyboard(); public abstract void mouse(); } //======================USB2.java=======================================基于抽象类

import com.dudu.app.USB; import com.dudu.app.USB2; import com.dudu.app.students; public class Hello { public static void main(String[] args){ computer computer1 = new computer(); computer1.test1(new USB() { @Override public void keyboard() { System.out.println(“基于接口的匿名内部类11111111111”); } @Override public void mouse() { System.out.println(“基于接口的匿名内部类222222222222”); } }); computer1.test1(new USB() { @Override public void keyboard() { System.out.println(“基于接口的匿名内部类33333333333333”); }

  1.      @Override
  2.      public void mouse() {
  3.          System.out.println("基于接口的匿名内部类4444444444444");
  4.      }
  5.  });
  6.  computer computer2 = new computer();
  8.  computer2.test2(new USB2() {
  9.      @Override
  10.      public void keyboard() {
  11.          System.out.println("基于类(抽象类)的匿名内部类 55555555555555");
  12.      }
  13.      @Override
  14.      public void mouse() {
  15.          System.out.println("基于类(抽象类)的匿名内部类 66666666666666666");
  16.      }
  17.  });

} }

class computer{ public void test1(USB AA){ AA.keyboard(); AA.mouse(); } public void test2(USB2 AA){ AA.keyboard(); AA.mouse(); } } //======================Hello.java=======================================

//使用内部类的主要特点是因为只使用一次；

  1. <a name="LUUDy"></a>
  2. #### 13.字符串
  4. 1. 字符串特性<br />a) 字符串常量是用双引号括起的字符序列。例如: "你好"、"100"、"xiaojianbang"等<br />b) String是final类, 不能被其他的类继承<br />c) String类有属性 private final char value[]; 用于存放字符串内容<br />d) String对象创建方式：直接赋值、调用构造器<br />e) String类的构造器有很多<br />f) 直接赋值和调用构造器，创建的字符串，是有区别的
  5. ```java
  6. public class Hello {
  7.  public static void main(String[] args){
  8.      String a = "xiaojianbang";
  9.      String b = new String("xiaojianbang");
  10.      System.out.println(a.equals(b));//true  内容比较
  11.      System.out.println(a == b);//false  内存地址比较
  12.  }
  13. }