多态，equals的视频笔记以及内部类的处理

1.使用向下转型需要注意的，以及模板

Person p=new Man();
//使用强转符:()
Man m=(Man)p;

可能ClassCastException异常

使用instanceof在进行向下转型前进行判断

if (p instaceof Man)
{
Man m=(Man)p;
}

2.重写equals()方法

class User{
String name;
int age;

public boolean equals(Object obj)
{
  if(obj==this)
{
return true;
}
if(obj instanceof User)
{
  User u=(User)obj;
return this.age==u.age&&this.name.equals(u.name);
}
return fasle;

}
}

3.1.为什么使用向下转型？

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何调用子类特有的属性和方法？使用向下转型

3.2.使用强制转换类型符（）

3.3.在向下转型前先进行instanceof的判断，一但返回true，就进行向下转型，否则，不进行向下转型

4.对多态性的理解

1.实现代码的通用性

2.Object类中定义的public boolean equals (Object obj){}

JDBC:使用Java程序操作（获取数据库连接，CRUD）数据库（MYSQL，Oracle,DB2,SQL,Server）

这些包装类继承于number类，number类又继承于Object类

成员内部类

1.在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量，语法如下：

class OuterClass{
     class  InnerClass{                      

                       }
}

在成员内部类中可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。

public class OuterClass{
private int age=1;
private void f()
{
}
class InnerClass{
void g()
{
f();
age++;
}
}
}

尽管成员变量age以及成员方法f()都在外部类中被修饰为private，但在成员内部类中可以直接使用。

内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。内部类初始化方式与其他类的初始化方式相同，都是使用new关键字。

public class Car {
    private String brand;//汽车品牌
    public Car(String brand)//创建构造器，brand为汽车品牌
    {
        this.brand=brand;//给汽车品牌赋值
    }
    class per{
        String name;//客户名字
        public per(String name,String brand)//使用构造器赋值客户信息和汽车品牌
        {
            this.name=name;
            Car.this.brand=brand;
        }
        public void tes()
        {
            System.out.println("这位"+this.name+"买了一辆"+Car.this.brand);
        }
    }
    public void test()
    {
        System.out.println("买了一辆"+this.brand);
    }
    
    public static void main(String[] args)
    {
        Car car=new Car("奔驰");
        Car.per n=car.new per("小明","宝马");
        n.tes();
    car.test();
    }
}

总结：成员内部类不止可以在外部类中使用，在其他类中也可以使用，在其他类中创建内部类对象的语法非常特殊，语法如下：

外部类 outer=new 外部类(）；

外部类.内部类 inner=outer.new 内部类(）；

** 2.匿名内部类**

1.匿名类不能写构造方法

2.匿名类不能定义静态的成员

3.如果匿名类创建的对象没有赋给任何引用变量，会导致该对象用完一次就会被Java虚拟机销毁

abstract class Dog{
public abstract void colortest();
}
public class demo{
public static void main(String[] args)
{
Dog a1=new Dog() {
public void colortest()
{
System.out.println("蓝色");
}
};
a1.colortest();
}
}

从这个结果可以看出 ，本来无法创建对象的抽象类竟然也可以出现在new关键字的右侧。为何叫匿名内部类?就是因为实例中Dog抽象类的实现类没有名称。创建的对象a1只能解读为“一只具体的无名之狗”

new 父类/父类接口(){ 子类实现的内容

}; //注意这里的大括号后面的分号