JAVA基础（三）

2018-06-18 本文已影响0人 Roper_被注册

局部变量和成员变量的区别?

在类中的位置不同：
成员变量在类中方法外；
局部变量在方法内或者方法声明上；
在内存中位置不同；
成员变量堆内存
局部变量栈内存
生命周期不同；
成员变量，随着对象的存在而存在，随着对象的消失而消失；
局部变量，随着方法的调用而存在，随着方法的调用完毕而消失；

形式参数分别为基本类型和引用类型的问题?

形式参数是基本类型，直接调用

形式参数是引用类型，要先实例化一个对象后，再通过对象调用

匿名对象是什么?应用场景是什么?

匿名对象是没有名字的对象，是对象的一种简化表示形式。列如new Student.show();
匿名对象使用在对象调用方法仅仅一次的时候和作为实际参数传递时候；

封装是什么?java中封装的体现有哪些?请举例说明。

封装指隐藏对象的属性的实现细节，仅对外提供公共访问的方式。

原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

this关键字是什么?this关键字的应用场景?

this关键字代表所在类对象引用。
方法被哪个对象调用，this就代表哪个对象。

构造方法的作用是什么?构造方法的特点是什么?构造方法的注意事项是什么?构造方法中可不可以写return语句呢?

构造方法的作用是给对象的数据进行初始化。

构造方法的格式
方法名与类名不同
没有返回值类型，包括void
没有具体的返回值
构造方法的注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的

给成员变量赋值有几种方式?

两种方式

Setxx()方法，修改属性值
构造方法，给对象中属性进行初始化

标准的代码编写及测试：

A: 学生类的案例
class Student{

    private String Name;
    private int age;
    private int grader;
    
    public Student(String name, int age, int grader) {
        super();
        Name = name;
        this.age = age;
        this.grader = grader;
    }
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getGrader() {
        return grader;
    }
    public void setGrader(int grader) {
        this.grader = grader;
    }

}

B: 手机类的案例
class Phone{
private String name;
private int price;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getPrice() {
    return price;
}

public void setPrice(int price) {
    this.price = price;
}



public Phone(String name, int price) {
    super();
    this.name = name;
    this.price = price;
}

}

C: 长方形类的案例
class Squal{
private double high;
private double length;

    public Squal(double high, double length) {
        super();
        this.high = high;
        this.length = length;
    }
    public double getHigh() {
        return high;
    }
    public void setHigh(double high) {
        this.high = high;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    
}

一个类的成员变量初始化过程

Student s = new Student();

将Student.class加载进内存
在占内存为s开辟空间
在堆内存为学生对象开辟空间
在学生对象的成员变量进行默认初始化
在学生对象的成员变量显示默认初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕，把对象地址复制给s变量

static关键字是什么?有什么特点?

static关键字可以修饰成员变量和成员方法。

static的特点：
随着类的加载而加载
优先于对象存在
被类的所有对象共享
可以通过类名调用

main方法各种修饰符及参数的解释?

main方法首先是静态的
public static void main(String[] arg){}

public 被Jvm调用，访问权限足够大
static 被Jvm调用，不用创建对象，直接类名访问
void 被Jvm调用，不需要给Jvm返回值
main 一个通用的名称，会被Jvm识别
String[] arg 以前用于接受键盘录入

代码块是什么?代码块的分类和各自特点?

代码块：在Java中，使用{}括起来的代码成为代码块
局部代码块：局部位置，用于限定变量的生命周期
构造代码块：在类中的成员位置。每次调用构造方法执行前，都会先执行构造代码块。作用：把多个构造方法的共同代码放在一起。
静态代码块：在类中的成员位置，只不过它用static修饰。

静态代码块,构造代码块,构造方法的执行流程?

静态随着类的加载而加载
静态代码块->构造代码块->构造方法的执行流程
静态代码块->构造代码块->构造方法
只要有子父关系，肯定先初始化父亲的数据，然后初始化子类的数据。

继承概述

多个类存在相同属性和行为时候，将这些内容抽取到单独一个类中，那么多各类无需再定义这些属性和行为，只要继承那个类即可。

继承的好处

提高复用性
提高维护性
让类与类之间产生了关系

Java中继承的特点

JAVA只支持单继承。
JAVA支持多层继承

Java中继承的注意事项?以及我们什么时候使用继承?

子类只能继承父类所有非私有的成员
子类不能继承父类的构造方法，但可以通过super关键字去访问父类构造方法
不要为了部分功能去继承

继承中构造方法的执行流程?假如父类没有无参构造方法，子类应该怎么办?

静态代码块->构造代码块->构造方法

子类通过super去显式调用父类其他的带参的构造方法
子类通过this去调用本类的其他构造方法

面试题：

方法重写和方法重载的区别?方法重载能改变返回值类型吗?

Overload:方法重载，提高通用性，只提供一个方法，但是参数类型和个数不同。可以改变返回值类型。

Override:方法重写，源于继承，父类方法不能满足子类的需要就可以重写父类的方法。

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this关键字代表本类对象引用,成员变量和局部变量重名时，可以用this来区分。
super关键字代表父类对象引用,从子类中调用父类的构造方法。
场景：
    成员变量：
        this.成员变量;
        super.成员变量;
    构造方法:
        this(…………);
        super(…………);
    成员方法：
        this.成员方法;
        super.成员方法;

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

修饰类，类不能被继承。
修饰变量，变量就编程了常量，只能被赋值一次
修饰方法，方法不能被重写

final关键字的面试题?

A: 修饰局部变量
在方法内部，该变量不可被改变。
在方法声明上，分别演示基本类型和引用类型作为参数的情况
基本类型：是值不能被改变
引用类型：是地址值不能被改变

B: 初始化时机
在对象构造完毕前

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

某一个事务，在不同时刻表现出来的不同形态
例如：猫 cat=new 猫();
动物 cat=new 猫();
使用多态的前提是要有继承关系，要有方法的重写，有父类引用指向子类对象

多态中成员访问的特点?

成员变量
编译看左边，运行看左边

成员方法
编译看左边，运行看右边

静态方法
编译看左边，运行看左边

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

好处
-- 提高了程序的维护性
-- 提高了程序的扩展性
弊端
-- 不能访问子类特有功能

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

向上转型
-- 从子到父
-- 父类引用指向子类对象
向下转型
-- 从父到自
-- 父类引用转为子类对象

抽象类概述及其特点?

抽象类和抽象方法必须用abstract关键字修饰
抽象类不一定有抽象方法，有抽象方法的一定是抽象类
抽象类不能被实例化，要实例化抽象类得按照多态的方式，由具体的子类实例化。
抽象类的子类不是抽象类就是重写抽象类的所有抽象方法

抽象类成员特点?

成员变量
可以是变量也可以是常量
构造方法
有构造方法，但是不能实例化
抽象类构造方法用于子类访问父类数据的初始化
成员方法
可以有抽象方法，限定子类必须完成某些动作
可以由非抽象方法，提高代码的复用性

抽象类练习?

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dog d=new Dog();
        d.setName("Roper");
        d.setAge(20000);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        
        Cat c=new Cat();
        c.setName("Rbao");
        c.setAge(3);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();

    }

}

abstract class Animal{
    private String name;
    private int age;
    
    public Animal() {}
    
    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 Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

//定义一个抽象方法
    public abstract void eat();
} 

class Dog extends Animal{
    public Dog() {}

    public Dog(String name,int age) {
        super(name,age);
    }
    
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("Dog eat meat");
    }   
}

class Cat extends Animal {
    public Cat() {}
    public Cat(String name,int age) {
        super(name,age);
    }
    public void eat() {
        System.out.println("Cat eat fish");
    }
}

抽象类的小问题

A: 一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
抽象类不一定有抽象方法，有抽象方法的一定是抽象类
增加了代码的可用性

B: abstract不能和哪些关键字共存
private 冲突
final 冲突
static 无意义

接口的概述及其特点?

定义事务功能的扩展性。

接口的成员特点?

接口用关键字interface
类实现接口implements表示
接口不能势力话
接口的子类

接口的练习?

    class JumpCat extends Cat implements Action{
    public JumpCat() {}
    public JumpCat(String name , int age) {
        super(name,age);
    }
    public void Action() {
        System.out.println("猫会跳");
    }
}

interface Action{
    public abstract void Action() ;
}

抽象类和接口的区别?