Java Day010 入门（final 继承多态）

最新推荐文章于 2021-03-19 18:41:46 发布

若能绽放光芒！

最新推荐文章于 2021-03-19 18:41:46 发布

阅读量177

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_41537499/article/details/102906372

版权

Java 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

1:final关键字可以干什么?有什么特点?

在继承关系中,有时候父类中的功能方法不想让子类进行覆盖或者重写,必须提供一个关键字:
final:最终的,终态的,无法更改的!
特点：
1.这个关键字是一个修饰符，可以修饰类，方法，变量。
2.被final修饰的类是一个最终类，不可以被继承。
3.被final修饰的方法是一个最终方法，不可以被覆盖。
4.被final修饰的变量是一个常量，只能被赋值一次。

2:final关键字的面试题?

A:修饰局部变量
B:初始化时机

3:多态是什么，前提是什么?

在同一时刻体现出事物的不同状态!
在面向对象Java语言中,多态的前提条件:
1)必须有继承关系
如果没有继承关系,无意义
2)必须有方法重写
子类中出现了和父类中方法声明一模一样的方法
3)必须父类引用指向子类对象(向上转型) ;
格式:父类名对象名 = new 子类名() ;

4:多态中成员访问的特点?

成员变量:
编译看左边,运行看左边
构造方法:在多态中,父类对象的创建时通过new 子类名(),优先让父类进行数据初始化
成员方法(非静态):
编译看左边,运行看右边
静态的成员方法:(静态成员方法算不上方法重写,因为静态跟类有关系)
编译看左边,运行看左边
在多态中成员方法 编译看左,运行看右

5:多态的好处及弊端？如何解决多态的弊端？

多态的好处：
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)
多态的弊端：
不能使用子类的特有功能。
怎么使用子类的特有功能
A:创建子类对象调用方法即可。(可以，但是太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题：
向上转型：
Fu f = new Zi();
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的.(所属关系)

6:什么是向上转型？什么是向下转型？

举例：

class Animal {
    public void eat () {
        System.out.println("Animal eat...");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("Dog eat");
    }
    
   public  void bark() {
        System.out.println("Dog bark");
    }  
}

向上转型就是把子类的对象转化为父类的对象，如：Animal animal = new Dog();
但是向上转型后，父类只能访问与子类共有的方法，如以下代码就会出现编译错误：
animal.bark(); //出错
向下转型则需要强制类型转换：
Animal animal = new Dog();
Dog dog = (Dog) animal;
总的来说，向上转型总是安全的，向下转型则未必，可能会发生ClassCastException.

7:多态编程题

a)不同地方饮食文化不同的
	南方人吃米饭
	北方人爱吃面
请使用多态的方式进行测试。

提示：
	1:人要吃饭
	2:南方人吃炒菜和米饭
	3:北方人吃烩菜和馒头
	先基本的调用，后多态调用。

	class Person{
	private String name;
    private int age;
    
    public Person() {
        
       }

   public Person(String name, int age) {

       	super();
       	this.name = name;
       	this.age=age;}
       	public String getName() {
       		return name;}

    public void setName(String name) {
    	this.name = name; }
       	public int getAge() {
       	 return age;
       	}

           public void setAge(int age) {
       	this.age = age;
       	}
       	public void show() {
       		System.out.println("姓名：" + name + "，年龄："+age); 
       	}
       	public void eat() {
		System.out.println("人都要吃饭");
	}
}
class North extends Person{
	public void eat() {
		System.out.println("爱吃烩菜馒头");
	}
	public void function() {
		System.out.println("北方人");
	}
	
}
class South extends Person{
	public void eat() {
		System.out.println("爱吃炒菜米饭");
	}
	public void function() {
		System.out.println("南方人");
	}
}

class test{
	public static void main(String[] args){
		
		Person p=new South();
		p.setAge(20);
		p.setName("zhang");
		p.show();
		p.eat();
		South s=(South)p;
		s.function();
		
		p=new North();
		p.setAge(40);
		p.setName("lee");
		p.show();
		p.eat();
		
		North n=(North)p;
		n.function();
		
	}
}

b)在猫狗案例，使用多态方式进行测试

	class Animal{
    public Animal(){}
    public void eat(){
        System.out.println("吃饭");
    }
}

//狗类 继承动物
class Dog extends Animal{
    public Dog(){}

    //重写方法
    public void eat(){
        System.out.println("狗吃肉");
    }
    //狗类特有的功能
    public void lookDoor(){
        System.out.println("狗看门");
    }
}
//猫类继承动物
class Cat extends Animal{ 
    public Cat(){}

    //重写方法
    public void eat(){
        System.out.println("猫吃鱼");
    }
    //猫类特有的功能
    public void playGame(){
        System.out.println("猫玩毛线");
    }
}

//测试类
class Test{
    public static void main(String[] args){
    //定义成猫
        Animal a= new Cat();
        a.eat();   //执行的是重写的方法
    //还原成猫
        Cat c= (Cat)a; //c引用了上面已有的猫对象（c指向了这个猫对象所在的堆内存空间 0x001)
        c.playGame();//这时便可以用猫特有的功能了
    //变成了狗  
        a= new Dog();//这里写的仍然是a，a又指向了一个狗对象
        a.eat();
    //还原成狗
        Dog d= (Dog)a;
        d.lookDoor();   
    }
}

8：看程序，写结果
1:看程序写结果（先判断有没有问题，如果没有，写出结果）

class Fu {
	public void show() {
		System.out.println("fu show"); 
	}	
}
class Zi extends Fu {
	public void show() {
		System.out.println("zi show");		
	}
	public void method() {
		System.out.println("zi method"); 
	}
}
	class Test { public static void main(String[] args) { 
		Fu f = new Zi(); 
			f.method();
	}
}

有问题，f.method(); The method method() is undefined for the type Fu
2:看程序写结果（先判断有没有问题，如果没有，写出结果）

class A { 
		public void show() {
			show2();		
		}
		public void show2() {
			System.out.println("我");
		}		
	}
	class B extends A {
		public void show2() { 
			System.out.println("爱");
		}
	}
	class C extends B { 
		public void show() {
			super.show(); 
		}
		
		public void show2() { 
			System.out.println("你");
		}
}
public class Test {
	public static void main(String[] args) { 
			A a = new B();
			a.show(); 
			B b = new C();
			b.show(); 
	}	
}

结果：爱
     你

9：请描述下this和super的区别？

通俗的讲，this指的是当前对象，super则指父类的。
（2）仅在了类中的构造方法中可以用“this（参数列表）”调用另一个构造方法，别的地方不可以这么用；
（3）可以用“this.成员变量”的方式引用成员变量。（适用于方法中局部变量和成员变量重名的情况）；
（4）super是在子类构造方法中调用父类的构造方法时的使用方法，并且此句必须在构造方法的第一行；
（5）super成员变量名可用于引用父类的成员变量。、
（6）super可用来引用被子类屏蔽的成员变量和成员方法。不过super是在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类。