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

目录

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

2.重写equals()方法

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

成员内部类


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 父类/父类接口(){   子类实现的内容

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

猜你喜欢

转载自blog.csdn.net/Wuweihendidiao/article/details/122358533

相关文章