局部变量和成员变量的区别?
1)代码的书写位置不同
局部变量:在方法定义中或者是方法声明上的变量
成员变量:类中方法外
2)内存中的位置不同
局部变量:在栈内存中
成员变量:在堆内存中
3)生命周期不同
局部变量:随着方法调用而存在,随着方法的调用结束而消失!(使用完毕,立即消失了)
成员变量:随着对象的创建而存在,随着对象的创建完毕,等待垃圾回收器自动回收而消失!
(对象创建完毕,对象可能被继续使用,所以不会立即消失!)
4)初始化不同:
局部变量:定义的时候,使用前必须初始化; 要么就是直接初始化,不能没有初始化值!
成员变量:随着类的加载而存在,存在系统默认初始化,可以不直接赋值! 也可以赋值
1.局部变量和成员变量的区别?
1)书写位置
局部变量:方法定义中或者方法声明上
成员变量:在类中方法外
2)内存位置不同
局部变量:在栈内存
成员变量:堆内存中
3)生命周期不同
局部变量:随着方法调用而存在,随着方法调用完毕而消失
成员变量:随着对象的创建而存在,随着对象创建完毕,等待GC垃圾回收器回收而消失
4)初始化不同
局部变量:可以直接初始化;先定义,在使用之前必须初始化!
成员变量:可以不初始化,由系统默认初始化(跟对象相关),构造方法初始化/显示初始化!
2.什么是this?this的作用是什么
this:代表就是当前所在的类对象的地址值引用!
this作用:就是为了区分局部变量隐藏成员变量
this.成员变量; 访问的当期类的成员变量
this.成员方法名() ; 访问的是当期类的成员方法
this(xx)/this() :访问的本类的有参构造方法/访问的本类的无参构造方法
3.什么是封装?
封装:就是将一个类的成员属性私有化(事物的属性隐藏),保证数据安全性,外界不能随意更改,对外提供公共访问
setXXX(xx)getXXX() ;
关键字:private
被private修饰的成员:成员变量/成员方法,只能在本类中访问,外界类不能直接访问,但是可以间接
通过公共的成员方法来访问!
4.什么是构造方法?构造方法的作用?
构造方法:
1)方法名和类名相同
2)没有具体返回值类型
3)连void都没有
作用:就是为了给当前类的成员变量进行数据初始化!
5.一个类的组成有哪些? 如何编写一个标准类?
一个类的组成:
成员变量
构造方法
成员方法
1.什么是代码块,代码块的分类以及优先级
在Java中,使用{}包起来语句多可以叫做代码块
局部代码块:在方法中定义(局部位置)
限定局部变量的生命周期
构造代码块
在类的成员位置{}
作用:可以的类的一些成员变量进行数据初始化(可以将构造方法中共有的内容存储在构造代码块中)
特点:每次执行构造方法之前,如果存在构造代码块,优先执行构造代码块
静态代码块
在类的成员位置
static{
}
它是随着类的加载而加载,类就加载一次,静态代码块仅仅执行一次~
静态代码块 > 构造代码块 > 构造方法
2.将一个变量定义为成员变量的时机问题(什么时候定义成员变量)
如果当前这些变量能够描述真实事物的属性;
这个时候将变量定义为成员变量,否则都是局部变量!
3.什么是继承,继承的好处是什么
将多个类的共性内容抽取到一个独立的类中,让这独立类和这些类产生一种关系 "继承"
继承的格式
class Fu{
}
class Zi extends Fu{}
继承的好处:
1)提高了代码的复用性
2)提高了代码维护性
3)类与类之间关系 ,是"多态"的前提条件
开发原则:
低耦合(程序之间的耦合),高内聚
4.private关键字的特点
private可以成员变量,可以修饰成员方法
这些变量/方法都只能在本类中访问;
这私有修饰的都可以间接通过公共方法访问!
5.static关键字的特点
1)被static修饰的随着类的加载而加载
2)优先于对象存在
3)不能this共存
4)有共享,共用的含义
5)修饰的变量/方法,访问方式:
类名.变量名;
类名.方法名() ;
1.继承中成员变量访问问题(父类成员变量名称和子类成员变量名称一致)
继承中:父类成员变量名称和子类成员变量名称一致
遵循"就近原则"
1)先在子类局部位置查找,如果存在,就使用
2)如果不存在,在子类的成员位置查找,如果存在,就使用
3)如果子类的成员位置不存在,在父类的成员位置中找,有就使用
4)如果父类成员位置没有,就没有这个变量,报错!
2.子类继承父类,如何访问构造方法?如果父类没有无参构造方法,如何访问
继承中,构造方法不能被继承的;子类的所有的构造方法都默认访问父类的无参构造方法 :super() ;
如果父类没有给出无参构造方法,子类的构造方法都会报错
解决方案:
1)手动给出父类的无参构造方法
2)间接通过访问父类的有参构造方法,让父类进行数据初始化; super(xx) ;
3)只要子类中的构造方法的一个能够让父类初始化即可!
可以先通过本类的无参构造方法,间接访问本类的有参构造方法:this(xx),
在通过本类的有参构造方法 :访问父类的有参构造方法:super(xx)
3.继承的好处以及特点有什么
继承的好处:
1)提高了代码的复用性
2)提高了代码的维护性
3)类与类之间产生继承关系,是"多态"的前提条件
继承的特点:
1)在Java中,只支持单继承,不支持多继承
2)虽然不支持多继承,可以多层继承!
4.final关键字的特点有哪些
final:状态修饰符,可以修饰类:该类不能被继承
可以修饰变量,此时这个变量是常量,只能被赋值一次,不能再次更改了!
成员位置:
public static final int xx = 值; 传统方式定义常量 普通格式(编译时期常量)
public final Student s = new Student() ; //实例(创建对象)变量 (运行时期常量)
修饰方法,此方法不被重写!
5.this和super的区别
this:代表当前类的对象地址值引用
super:代表父类空间标识(父类对象的地址值引用)
this.变量名; 访问的本类的成员变量
super.变量名; 访问的是父类的成员变量
this.方法名() ;访问本类的成员方法
super.方法名() ; 访问的父类的成员方法
this() ; 访问本类的无参构造方法
super() ;访问父类的无参构造方法
this(xxx) ;访问本类的有参构造方法
super(xxx);访问的父类的有参构造方法
6.方法重写和方法重载的区别
public String eat() {
return "xx" ;
}
public String eat(){
}
Override:继承关系中,子类出现了父类一模一样的方法声明,子类的方法将父类的方法覆盖掉了,
使用子类的功能!
Overload:定义多个方法的时候,这个方法(功能)可以提高代码的扩展性,可以针对同一个功能,传递不同类型的参数
方法名相同,参数列表不同,和返回值无关!
参数类型不同,
参数个数不同
参数类型顺序...
1.什么是多态,多态的成员访问特点
多态:一个事物在不同时刻体现的不同形态(内存中的变化)
前提条件
1)存在继承关系
2)存在方法重写
3)父类引用指向子类对象 Fu fu = new Zi() ;
多态的成员访问特点:
成员变量: 编译看左,运行看左!
成员方法:编译看左,运行看右,由于存在方法重写,子类的功能将父类的功能覆盖了!
静态的方法:算不上方法重写,编译看左,运行看左: static修饰的都是和类相关的
2.多态的好处有哪些以及弊端
好处:
1)提高了代码的复用性(由继承保证)
2)提高了代码的扩展性(由多态保证)
//有动物类Animal
继承关系
有猫类Cat
有狗类Dog
//Java23设计模式 :创建型设计模式 结构型设计模式 行为型设计模式
class AnimalFactory{ //动物工厂 ----> 静态工厂模式
private AnimalFactory(){}
//创建很多个动物
public static Cat creatCat(){
Cat c = new Cat() ;
return c ;
//return new Cat() ;
}
public static Dog creatDog(){
return new Dog() ;
}
//优化
public static Animal createAnimal(String type){
if("dog".equals(type)){
return new Dog() ;
}else if("cat".equals(type)){
return new Cat() ;
}else{
System.out.println("对不起,此工厂不提供这个动物的创建") ;
}
}
}
//测试
Animal a = AnimalFactory.createAnimal("dog") ; //Animal a = new Dog() ; 多态的应用
传统方式---> 不好优化
Cat c = new Cat() ;
Dog d = new Dog() ;
Animal a = new XXX() ;
3.什么是抽象类?抽象类的本质是什么
抽象类:
一个事物如果存在抽象功能,那么这个类一定是抽象类!
抽象类:在真实事物中,它是一个泛指(概括性的事物,非具体事物) abstract 修饰
抽象类中不一定有抽象方法,也可以是非抽象方法!
抽象类的本质:强制子类必须完成的事情(要将抽象类中的所有的抽象方法必须重写!)
4.封装,继承,多态是什么?
封装:
将一个事物的属性私有化,保证其数据的安全性(隐藏),对外提供公共访问方法操作!
开发中:
1)定义这个类--- 实体类 User类 ,Order订单类,Product商品类...
2)需要封装这个类:获取数据
类名 对象 = new 类名() ;
有参构造方法/setXXX(xx):赋值 :形式参数----->数据库中查询到
User user = new User() ;
user.setUserName("zhangsan") ;
继承:
将多个事物的共有属性抽取出来,在一个独立类中定义,然后独立的类和这些产生一个关系: extends
目前---->学习继承---Object :以及Java高级部分----->jdk提供类,核心接口----之间就会继承体现!
开发中:
1) 用户类 ---- > 数据库: user表
用户名称
用户名密码
2) 订单类: -----> 数据库:order表
订单编号:orderId
订单小计金额:subtotal
针对多表之间查询:
查询订单信息的同时查询出 订单属于哪个用户的
订单类中并没有用户的信息
单独定义一个类:OrderUser extends Order
用户名称
用户名密码
多态:
一个事物在不同时刻体现的不同形态(内存中的变化)
开发中:提高代码的扩展性
Fu f = new Zi() ; //Fu类:具体类----> 具体类多态
Fu f = new Zi() ; //Fu类:抽象类----> 抽象类多态(其次)
接口类型 对象名 = new 接口的子实现类() ; ---->接口多态 (使用居多)
后期:压根项目中就见不到new 关键字----全部都是通过底层(反射技术---(内省))创建该类对象:
5.static关键字的特点
1)随着的加载而加载,加载一次,被静态修饰的先进内存
2)优先于对象存在 :不能和this共存
3)可以被多个对象共享,共用
4)可以被类名直接访问
类名.方法名();
类名.变量名 ;
1.抽象类和接口的区别
1)成员的区别
成员变量:抽象类中可以是常量,也可以是变量
接口:只能是常量:存在默认修饰符 public static final
构造方法:抽象类:存在构造方法,无参/有参-----由于有继承关系,父类先初始化,子类在初始化
接口:没有构造方法
成员方法:抽象类中,既可以是抽象方法,也可以是非抽象方法
接口:只能是抽象方法,存在默认的修饰符:public abstract
2)关系区别:
类与类(类:具体类/ 抽象类):都是继承关系:extends,而且只支持单继承,不支持多继承,可以多层继承!
类与接口的关系:(类:具体类/抽象类---具体的子类):实现关系: implements
一个类继承另一个类的同时,可以实现多个接口
接口与接口的关系:继承关系: extends 可以单继承,也可以多继承!(也可以多层继承)
3)设计理念的区别:
抽象类:由于存在继承关系,继承关系体现的是一种"is a"的关系---->A类是B类的一种,或者B类是A类的一种
接口: 描述某个事物本身不具备的额外功能---->扩展功能,体现的一种"like a"的关系,A类类似于B类
猫狗案例+接口+多态
猫和狗:一部分具备跳高的功能---JumpCat/JumpDog
2.如果方法的形式参数是一个数组类型,实际参数应该传递什么?
public void printArray(int[] arr){ //实际参数应该传递的是当前数组对象!
...
}
3.什么是接口,接口的定义格式以及接口和类之间的关系,请代码列举
描述某个事物本身不具备的额外功能---->扩展功能,体现的一种"like a"的关系
interface 接口名{}
class 接口的子实现类名 implements 接口名{}
interface Love{
public abstract void love() ;
}
class LoveImpl implements Love{
public void love(){
System.out.println("爱生活,爱Java,爱高圆圆...") ;
}
}
4.多态的成员特点以及多态的好处
格式:Fu fu = new Zi() ;
成员变量:编译看左,运行看左
成员方法:编译看左,运行看右
构造方法:分层初始化;new Zi()----->
先执行父类的构造方法----父类初始化完毕,然后执行子类构造方法,完成子类的初始化操作
多态的好处:
1)提高代码复用性(继承来保证)
2)提高代码的扩展性(多态完成) 接口多态/抽象类多态
5.this和super的区别
this:代表的本类(当前类)对象的地址值引用
this.变量; 本类的成员变量
this.方法名(); 本类的成员方法
this();本类的无参构造方法
this(xx);本类的有参构造方法
super:代表父类的空间标识(父类的对象地址值引用)
super.变量; 父类的成员变量
super.方法名(); 父类的成员方法
super();父类的无参构造方法
super(xx);父类的有参构造方法
6.abstract和哪些关键字冲突,为什么
abstract关键字:可以修饰类,可以修饰方法(抽象方法)----使用居多
private :本private修饰的只能在本类访问方法,外界类不能访问
static: static随着类的加载而加载,而当前抽象方法需要被子类重写,通过对象名访问的,static又优先于对象存在
final: 被final修饰的方法不能被重写,而抽象方法需要被子类重写,就冲突了
public:公共的:可以使用的
protected:受保护的:可以使用的
同一个包下的
当前类中可以访问
同一个包下的
子类
不同包下的
子类
默认修饰符:可以默认使用
1.默认修饰符,private,protected,public修饰符他们的范围
同一个包下的本类中 在同一个包下的子类/无关类中 在不同包下的子类中 在不同的包无关类中
private Y
默认修饰符 Y Y
protected Y Y Y
public Y Y Y Y
2.方法的形式参数是具体类型,抽象类,接口,实际参数如何传递
方法的形式参数是具体类型:实际需要传递的该具体类 对象
抽象类:实际参数需要传递该抽象类的子类对象
接口:实际参数需要传递该接口的子实现类对象
方法的返回值是具体类型,抽象类,接口,该方法需要如何返回
方法返回值类型是引用类型:
具体类型:返回的是当前类的具体对象
抽象类:返回的是当前抽象类的子类对象
接口:返回的是接口的子实现类对象
Java: 面向接口编程的
把接口暴露出来 ---- 开发者去针对接口来完成自己的业务功能!
3.接口的成员特点
成员变量:只能是常量:public static final
成员方法:只能是抽象方法:public abstract
没有构造方法
4.带包如何进行编译和运行
方式1:手动方式
1)进入java文件所在目录,然后编译 javac java源文件--->类名.class
2)需要手动方式创建文件夹: package com.qf;
3)把1)中产生的类名.class 放在qf文件夹下
4)直接带包运行
java com.qf.类名;
方式2:自动方式
1)针对带包的java文件直接编译
javac -d . java源文件----> com
qf
类名.class
2) 直接带包运行
java com.qf.类名;
针对不同包java文件---必须先导包:然后将被导入的类---->先进行编译
然后针对当前要执行类--使用自动方式进行编译和运行即可!
5.请阐述你对多态的理解? 应用方面如何使用
多态:
继承/重写/父类引用指向子类对象
任何父类出现的地方,都可以使用子类型 Fu fu = new Zi() ;
应用方面:
接口多态使用居多!(讲 集合:List接口---->子类实现类之一:ArrayList)
使用集合作为 "数据库"
模拟用户登录/注册操作
子类继承父类,在父类中是可以获取子类对象!(反射....)
class Fu{
//提供main方法
// 类名.class属性----->直接获取子类的字节码文件对象:包名.Zi.class (反射技术)
}
class Zi extends Fu{
public void method(){
}
}
class Outer5{
private int num = 20 ;
public void method(){
//局部变量
int num2 = 50 ;
//局部内部类
class Inner5{
public void show(){
System.out.println(num);
System.out.println(num2);
}
}
Inner5 inner5 = new Inner5() ;
inner5.show();
}
}
public class OuterDemo5 {
public static void main(String[] args) {
//访问Inner5中的show
//创建外部类对象.调用method
Outer5 outer5 = new Outer5() ;
outer5.method();
}
}
扫一扫
201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
