多态
//多态中成员的特点
接口的特点
多态的应用三:
Object中 几个 常用的方法
/**
* 多态: 可以理解为事物存在的多种体现形态
*
* 人:男人 女人 动物 : 猫,狗
*
* 猫 x=new 猫(); 动物 x=new 猫();
*
* 1.多态的体现
* 父类的引用指向子类的对象
* 父类的引用可以接受自己的子类对象
* 2.多态的前提
* 类和类之前要有关系,要么继承,要么实现
* 通常还有一个前提:存在覆盖.
* 3.多态的好处
* 多态的初相大大的提高程序的扩展性
* 4.多态的弊端
* 提高了扩展性,但是只能使用父类的引用访问父类中的成员
* 5.多态应用
*
* 6.多态出现代码中的特点(多态使用注意事项)
*
*
*/
abstract class Animal{
public abstract void eat();
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
public void eat() {
System.out.println("啃骨头");
}
public void kanJia(){
System.out.println("看家");
}
}
class Pig extends Animal{
public void eat() {
System.out.println("饲料");
}
public void gondDi(){
System.out.println("拱地");
}
}
public class DuotaiDemo {
public static void main(String[] args) {
Cat c=new Cat();
c.eat();
Dog d=new Dog();
d.eat();
function(new Cat());
function(new Dog());
function(new Pig());
// 父类的引用指向指向子类的对象
Animal ac=new Cat(); //类型提升,向上转型 将猫转型 成父类型
function(ac);
Animal ad=new Dog();
function(ad);
//如果想要调用猫的特有方法时
//强制父类的引用,装成子类型
Cat cc=(Cat)ac; //向下转型
cc.catchMouse();
}
/*public static void function(Cat c){
c.eat();
}
public static void function(Dog d){
d.eat();
}
//一年后 养猪了
public static void function(Pig p){
p.eat();
}
*/
//提高代码的扩展性 可以将下面的封装成一个 工具类 专门用来操作这一类对象的
public static void function(Animal a){
a.eat();
//instanceof :在子类是有限的时候可以判断 . 判断后 然后在应用其 特定的方法.
if(a instanceof Cat)
((Cat) a).catchMouse();
else if(a instanceof Dog)
((Dog) a).kanJia();
else if(a instanceof Pig)
((Pig) a).gondDi();
}
//多态中成员的特点
/**
* 多态中成员的特点
* 非静态成员函数: 成员函数在多态调用时,编译看着左边,运行看右边.
*
* 成员变量: 都参考左边(应用类型所属的类)
* 静态成员函数: 无论编译和运行 都参考左边
*
*/
class Fu {
int num=5;
static int num1=5;
static final int num2=5;
void method1() {
System.out.println("Fu_method1");
}
void method2() {
System.out.println("Fu_method2");
}
//静态
static void method4() {
System.out.println("Fu_method4");
}
}
class Zi extends Fu {
int num=8;
static int num1=8;
static final int num2=8;
void method1() {
System.out.println("Zi_method1");
}
void method3() {
System.out.println("Zi_method3");
}
//静态
static void method4() {
System.out.println("Zi_method4");
}
}
public class DuotaiDemo1 {
/**
* @param args
*/
public static void main(String[] args) {
//方法
Fu f=new Zi();
f.method1(); //打印 Zi_method1
f.method2(); //打印 Fu_method2
//f.method3();编译失败
f.method4();
Zi z=new Zi();
z.method1(); //打印 Zi_method1
z.method2(); //打印 Fu_method2
z.method3(); //打印 Zi_method3
z.method4();
//变量
Fu ff=new Zi();
System.out.println(ff.num); // 5
System.out.println(ff.num1); // 5
System.out.println(ff.num2); // 5
Zi zz=new Zi();
System.out.println(zz.num); // 8
System.out.println(zz.num1); // 8
System.out.println(zz.num2); // 8
}
接口的特点
/**
* 需求:
* 电脑运行实例:
* 电脑运行基于主板.
*
* 多态应用
* 接口:降低耦合性,提高程序的扩展性.提供了规则
*/
class MainBoard1{
public void run(){
System.out.println("mainboard run");
}
//升级一
public void userNetCard(NetCard1 c){
c.open();
c.close();
}
}
//升级 一:要上网 怎么办?
class NetCard1{
/**
* 发现 耦合性很高,如果要听音乐 ,需要 取下这个网卡
*/
public void open(){
System.out.println("NetCard open");
}
public void close(){
System.out.println("NetCard close");
}
}
//升级二 :要听音乐 (主板厂商 召集个功能卡开发商 开会 ,定义PCI插槽规则)
interface PCI{
public void open();
public void close();
}
class MainBoard{
public void run(){
System.out.println("mainBoard run");
}
public void userPCI(PCI p){ //接口的引用 执行 子类的对象
if(p!=null){
p.open();
p.close();
}
}
}
class NetCard implements PCI{
@Override
public void open(){
System.out.println("NetCard open");
}
@Override
public void close(){
System.out.println("NetCard close");
}
}
class SoundCard implements PCI{
@Override
public void open(){
System.out.println("SoundCard open");
}
@Override
public void close(){
System.out.println("SoundCard close");
}
}
//测试
public class DuoTaiDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MainBoard1 mb1=new MainBoard1();
mb1.run();
//升级一
mb1.userNetCard(new NetCard1());
//升级二
MainBoard mb=new MainBoard();
mb.run();
mb.userPCI(null);
mb.userPCI(new NetCard());
mb.userPCI(new SoundCard());
}
}
多态的应用三:
/**
* 需求: 数据库的操作
* 数据是:用户信息
* 1.连接数据库
* 2.操作数据库 JDBC HIBERNATE
* CRUD
* 3.关闭数据库连接
*/
//升级三
interface UserInfoDao{
public void add(User user);
public void delete(User user);
}
class UserInfoByJDBC implements UserInfoDao{
public void add(User user){
/*
* 1.JDBC连接数据库
* 2.使用sql添加语句添加数据
* 3.关闭连接
*/
}
public void delete(User user){
/*
* 1.JDBC连接数据库
* 2.使用sql添加语句删除数据
* 3.关闭连接
*/
}
}
//升级 1: 公司数采用 hibernate框架
class UserInfoByHibernate implements UserInfoDao{
public void add(User user){
/*
* 1.Hibernate连接数据库
* 2.使用sql添加语句添加数据
* 3.关闭连接
*/
}
public void delete(User user){
/*
* 1.Hibernate连接数据库
* 2.使用sql添加语句删除数据
* 3.关闭连接
*/
}
}
public class DuoTaiDemo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
UserInfoByJDBC ui=new UserInfoByJDBC();
ui.add(user);
ui.delete(user);
//升级 1: 公司要求采用 hibernate框架 发现修改代码的时候还是挺麻烦的
UserInfoByHibernate uh=new UserInfoByHibernate();
uh.add(user);
uh.delete(user);
//采用多态
UserInfoDao ud=new UserInfoByHibernate();
ud.add(user);
ud.delete(user);
}
}
Object中 几个 常用的方法
/**
*Object 是所有对象的直接或者间接父类.该类定义的肯定是所有对象 所有具备的功能
*
*Object 中已经提供了对象是否相同的比较方法,我们只需要重写
*/
class Demo //extends Object
{
Demo(){
super();//默认调用 Object
}
private int num;
Demo(int num){
this.num=num;
}
public boolean compare(Demo d){
return this.num==d.num;
}
//使用Object 的比较方法
public boolean equals(Object obj){ // Object obj=new Demo();
if(!(obj instanceof Demo)) //判断类型
return false;
Demo d=(Demo)obj; //向下转型
return this.num==d.num;
}
public String toString(){
return "Demo"+num;
}
}
class Person{
}
public class ObjectDemo {
public static void main(String[] args) {
System.out.println("========equals===========");
Demo d1=new Demo(4);
Demo d2=new Demo(5);
Demo d3=d1;
System.out.println(d1.equals(d2));
System.out.println(d1==d2);
System.out.println(d1==d3);
Person p=new Person();
System.out.println(d1.equals(p));
System.out.println("========toString===========");
System.out.println(d1.toString()); //打印 d1所属类型 和 在内存地址中的值
System.out.println(Integer.toHexString(d1.hashCode()));
Class c=d1.getClass();
System.out.println(c.getName());
System.out.println(c.getName()+"@"+Integer.toHexString(d1.hashCode()));
System.out.println(d1.toString());
}
}