11.7晨写：
1.什么是方法重载
Overload,定义方法,方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)参数个数
2)参数类型
3)参数类型的先后顺序
重载目的:为了提高这个方法扩展,同一个方法可以传递不同类型的参数! (jdk提供很多工具类,java.lang.Math /java.util.Arrays(数组工具类),java.util.Collections...)
2.this关键字是什么?
this的出现,局部变量隐藏了成员变量,所以通过this关键字区分;
this:代表类对象的地址值引用;
class Student{
private String name ;
public void setName(String name){ //setXXX方法赋值
this.name = name ;
}
}
自己手写,或者通过idea自动生成---alt+ins--->getter and setter 3.一个标准类的写法
//一个类的属性私有化,对外提供公共的成员方法setXXX()/getXXX()
class Student{
private String name ;
private int age ;
public void setName(String name){
this.name = name ;
}
public String getName(){
return name ;//隐藏了this关键字,可以不写
}
public void setAge(int age){
this.age = age ;
}
public int getAge(){
return age ;
}
}
//类名 对象名 = new 类名();
//Student s = new Student() ;4.给成员变量赋值有几种方式?
有两种方式
public void setName(String name){
this.name = name ;
}
类的setXXX()方法赋值
方式2:
通过构造方法
5.什么是类?
类,是描述一个事物的一组属性和行为的集合!
事物---- 对应----- 类
属性 类中方法外,定义的成员变量
行为 类中的成员方法,定义成员方法(去掉static)
11.8晨写：
1.代码块的优先级：静态代码块>构造代码块>构造方法
2.什么是继承？继承的特点以及好处分别是什么？
将多个事物(类)的共性内容抽取到一个独立的事物(类)中,这个事物(类)和其他事物(其他类)之间
产生一种关系,称为"继承" 。
继承的特点:
1)提高了代码的复用性
2)提高了代码的维护性(方便后期维护)
3)类与类产生的继承关系,是多态的前提条件!
3.static 关键字的特点？
1）随着类的加载而加载，类一加载，跟静态相关的直接加入内存区域（static区）
2）优先于对象存在（创建对象的前提，需要加载类的首先），不能this共存
3）具备“共享，共用”的意思，如果需求中有共享，共用这种含义，这个时候需要将
变量定义static
4）访问方式：
被静态修饰的变量及方法（类成员）--都直接类名访问
类名.变量名；
类名.方法名；
4.成员变量和静态变量的区别？
1）在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
2）在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
3）生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
4）初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使
5.继承的弊端，什么时候使用继承？
继承的弊端 :具有局限性,继承了一个类,可以将这个类里面的所有的非私有的方法继承过来,有的功能不需要
不能为了使用类的部分功能,去使用继承!
使用继承的时机:当类A是类B的一种或者类B是类A的一种,使用继承 ,体现 "is a"的关系
11.9晨写：
1.什么是方法重写？
Override，在继承关系中，子类出现了一模一样的方法声明，子类将父类的方法覆盖了，
实现自己的业务逻辑。。。
2.final关键字的特点
final修饰类，该类不能继承
final修饰变量，此时变量是一个常量（自定义常量）
编译时期常量： public static final 基本数据类型 变量名 = 值；
运行时期常量：
final修饰成员方法，该方法不能被重写
3.继承中构造方法的访问问题（子类如何访问父类的构造方法）
子类所有的构造方法默认访问父类的无参构造方法(子类所有构造方法的默认第一句话:隐藏super())
父类中没有给出无参构造方法,只存在有参构造方法,子类的所有构造方法会报错,如何解决
1)给出父类的无参构造方法
2)让子类的所有的构造方法,显示的访问父类的有参构造方法(让父类先数据初始化)
3)子类中的某一个构造方法能够让父类初始化即可!
4.this和super的区别
1)概念的区别
this:代表的当前类对象的地址值引用
super:代表的父类的空间表示(父类对象的地址值引用)
2)使用不同
2.1)针对成员变量访问
this.变量名 ; 访问的本类的成员变量
super.变量名; 访问的父类成员变量
2.1)访问构造方法
this() ; 访问本类的无参构造方法
this(xx); 访问本类的有参构造方法
super() ;访问父类的无参构造方法
super(xx);访问父类的有参构造方法
2.2)访问成员方法
this.方法名() ;访问本类的成员方法
super.方法名() ;访问父类的成员方法
5.多态的前提条件以及成员访问特点
多态的前提条件：
1)必须有继承关系 (如果没有继承,不谈多态)
2)必须存在方法重写
3) 必须存在父类引用指向子类对象
多态的成员访问特点:
1)成员变量:编译看左,运行看左!
2)成员方法:编译看左,运行看右 !(非静态的成员方法)
静态的方法:算不上方法重写,这种 跟类相关,类一加载就可以直接使用(类名.方法名())
3)构造方法:由于存在继承,构造方法在执行的时候,分层初始化,先让父类初始化,然后再是子类进行
构造初始化!
成员访问特点:
父类名 对象名 = new 子类名();
1)成员变量(非静态):编译看左,运行看左!
2)成员方法(非静态):编译看左,运行看右(因为子类存在重写)
静态的成员方法:算不上方法重写,跟类相关,类名.静态方法名() ; 编译看左,运行看左!
3)构造方法: 由于存在继承关系,分层初始化(先让父类初始化,然后再是子类初始化!)
6.多态的好处及弊端，针对弊端如何解决？
1)可以提高代码的扩展性 (父类引用指向子类对象 Fu fu = new Zi())多态保证的 (重点)
2)可以提高代码的复用性以及维护性(由继承保证的)
多态的弊端:
父类引用指向子类对象, 父类名 对象名 = new 子类名() ;(向上转型)这种格式无法访问子类的特有功能
解决方案:
1)直接创建子类对象 子类名 对象名 = new 子类名() ;
虽然可以,但是new 子类名() ;需要开辟堆内存空间(消耗内存空间) (内存角度考虑不太好)
2) 推荐:向下转型
将父类引用强转为子类引用!-----就是我们 基础"强转类型转换" (将大类型---小类型)
int num = 65 ;
char c = (char)num ; // 'A'
父类名 父类的引用 = new 子类名() ; 向上转型
Fu f = new Zi() ;
子类名 对象名 = (子类名)父类的引用; 向下转型 --前提必须有向上转型
Zi z = (Zi)f;
11.10晨写：
1.什么是抽象类？他有什么特点
有抽象方法的类一定是抽象类；
一个事物的某个行为应该具体的事物的具体体现,将这个事物顶层次(父类)可以定义"抽象"
抽象类的特点:
1)抽象类最大的特点：强制子类必须完成的事情
2)抽象类不能进行实例化! (不能 创建对象)
3)抽象类的子类如果也是抽象类,不能实例化,一定会提供最具体的子类 完成实例化(创建对象)
抽象的父类名 对象名 = new 具体的子类名() ; 抽象类多态
抽象类的成员特点
1)成员变量：皆可以变量，也可以常量
2)成员方法：可以抽象方法，也可以存在非抽象方法
3)构造方法：无参/有参构造都存在，因为存在继承关系，还需要分层初始化的
2.什么是接口？它的特点
接口 体现的是这个事物本身不具备的功能,额外的功能;
接口的特点:
1)定义格式 interface 接口名{}
2)不能实例化
3)接口的子类最终肯定有一个具体类，否则无法创建实例
接口的成员特点：
1)成员变量：只能是常量--->存在默认修饰符 public static final（可以省略不写）
2)成员方法：只能是抽象方法---->存在默认修饰符public abstract（可以省略）
3) 构造方法：无
3.abstract不能和哪些关键字使用
1）不能private一块用:被private修饰的成员需要在当前类进行访问,而如果加入abstract,强制子类完成
2）不能和final一块用: 被final修饰的成员方法,不能被重写!而abstract抽象方法,必须强制子类重写
3）不能和static一块用:被static修饰的成员方法,算不上重写
4.方法的形式参数如果是引用类型-->类，调用方法实际参数如何传递？
如果形式参传递的是一个具体类---->需要调用的时候，传递当前具体类 对象
interface Inter{
//添加用户
void add(User user) ;//形式参数里面就是引用类型 User类型--->调用方法的时候应该创建User对象
//User[] findAll() ;
}
class User{
private String name ;//用户名
private String password;//密码
//setXXX(xx)/getXXX()
//无参/有参构造...
}
//接口的实现类
class InterImpl implements Inter{
//添加用户
void add(User user){
//数组 容器---->后面集合Collection /Map
//定义一个数组---->专门存储User对象的
//int[] arr = new int[数组长度] ; //数据类型[] 数组名称= new 数据类型[数组长度] ;
User[] users = new User[5] ;
//给数组将user对象添加进去
}
}
//测试类---->
//接口多态
Inter inter = new InterImpl() ;
User user = new user() ;
inter.add(user对象) ;
5.类与接口的关系？
实现关系------------------>implements
class 子实现类名 implements（接口名）
11.11晨写：
1.形式参数如果是接口，实际参数如何传递？形式参数如果是抽象类，实际参数如何传递？
形式参数是一个接口,
调用方法的时候,实际参数应该传递接口的子实现类对象!(接口多态)
形式参数是一个抽象类,
调用方法时,实际参数需要传递该抽象类的子类对象(抽象类多态)
2.方法返回值如果是接口，方法返回什么？/返回值如果是抽象类，方法返回什么？
方法返回值是一个接口，该方法结束需要返回该接口的子类对象（接口多态）
方法返回值是一个抽象类，该方法结束需要返回该抽象类的子类对象（抽象类多态）
3.外部类如何直接访问成员内部类的成员？
格式：
外部类名.内部类名 对象名 = new 外部类名（）.new 内部类名（）；
对象名.成员内部类的成员；
4.外部类如何直接访问静态成员内部类的成员？
格式：
外部类名.内部类名 对象名 = 外部类名.内部类名（）；
对象名.静态成员的内部类的成员；
如果静态的成员内部类的成员方法也是静态的：
外部类名.内部类名.静态方法名（）；
静态的成员内部类里面的成员无论是静态还是非静态的访问外部类的成员必须是静态！
5.权限修饰符 默认/私有/受保护/公共 他们的使用范围？
在同一个包下的同一个类中 都可以访问
在同一个包下的子类中/在同一个包下的无关类中 只有私有不能访问
在不同包下的子类中 私有和默认不能访问
不同包的无关类中 默认，私有，受保护的不能访问
面试题：
this和super的区别?
this:代表的当前类对象的地址值引用
super:代表父类的空间表示(父类的对象的地址值引用)
使用不一样:
this.变量名 : 访问本类的成员变量
super.变量名: 访问父类的成员变量
this.方法名() ; 访问本类的成员方法
super.方法名(); 访问父类的成员方法
this() :访问本类的无参构造方法
this(xx): 访问本类的有参构造方法
super():访问父类的无参构造方法
super(xx):访问父类的有参构造方法
方法重写Override和方法重载Overload的区别?
方法重载Overload :
定义方法的时候,多个方法的方法名相同,参数列表不同,与返回值无关(目的:提高了方法扩展性)
参数列表不同:
1)参数个数
2)参数类型
3)先后类型顺序
方法重写Override:
在继承中,子类出现了和父类一模一样的方法声明,子类会将父类的方法覆盖,使用子类的一些自己功能;
重写的时候,要保证访问权限足够大!(重写的目的:为了沿用父类功能,然后还可以自己的优化的功能!)
局部内部类的面试题(局部内部类访问局部变量 jdk7以前必须加入final):
/* 局部内部类:
* 1)也可以访问外部类的成员包括私有
*
* 2)面试题:局部内部类访 访问它的成员方法里面的局部变量,局部变量有什么特点?(重点)
*
* jdk7以前(包括jdk7):局部内部类访问局部变量的时候,局部变量必须使用Ũ nal进行修饰!,为什么?
*
* 局部变量它随着方法调用而存在,随着方法调用结束而消失,但是现在是通过局部对象调用它的成员方法还在使用这个
局部变量
* 局部变量必须为常量(加入Ũ nal)---局部内部类对象不会立即消失,等待gc回收!
*
*
* jdk8以及jdk8以后 jvm已经对这个局部变量优化 ,将Ũ nal已经省略了!
*/
//外部类
class Outer{
//成员
private int num = 20 ;
public int num2 = 50 ;
//成员方法
public void method(){
//局部内部类
class Inner{
//局部内部类的成员方法
public void show(){
//局部变量
int x = 100 ;
2. 内部类面试题2
System.out.println(num2) ;
System.out.println(num);
System.out.println(x);
}
}
//访问show()方法
Inner inner = new Inner() ;
inner.show();
}
}
//测试类
public class InnerClassDemo {
public static void main(String[] args) {
//创建外部类对象,调用成员方法method
Outer outer = new Outer() ;
outer.method();
}
}接口和抽象类的区别?
1)成员的区别
抽象类:
成员变量:既可以是常量,也可以变量
成员方法:既可以是抽象方法,也可以是非抽象方法
构造方法:无参/有参构造都存在,子类父类继承,需要分层初始化
接口
成员变量:只能是常量 public static final(默认修饰符)
成员方法:只能是抽象方法 public abstract(默认修饰符)
构造方法:没有---需要借助子实现类进行实例化(创建对象)
2)关系的区别
类与类:可能是一些抽象类, 继承关系,只支持单继承,不支持多继承,但是可以多层继承
abstract class Animal{}
abstract class Cat extends Animal{}
class XXCat extends Cat{}
类与接口:实现关系 implements
一个类继承另一个类(可能也是抽象类)的同时,还可以实现多个接口
接口与接口:继承关系 extends
支持单继承,可以多继承,多层继承!
3)设计理念的区别
抽象类--不能实例化
需要通过具体的子类实现类(继承关系)
核心设计理念体现都是一种"is a"的关系(xxx是XX的一种)
接口---不能实例化
需要通过具体的子实现类进行实例化(实现关系implements)
核心设计理念体现的是 事物的一种额外功能
看成一种"like a"的关系
注意事项：
继承的注意事项(重点)
1)子类继承父类,继承父类的非私有的成员,私有的成员,可以间接访问!
2)子类继承父类,构造方法是不能继承的,通过一个关键字来访问 super() (在继承 super的使用)
继承的成员变量访问问题(重点)
1)子类继承父类,如果子类和父类的成员变量名称不一致,(分别访问即可)
2)子类继承父类,子类和父类的成员变量名称一致,访问(采用"就近原则")
继承的构造方法访问问题 :super来访问(重点)
1)子类继承父类,子类的所有构造方法的默认第一句话都super() ;(可以省略的不写) 访问父类的无参构造方法
2)如果父类中没有给出无参构造方法, 那么会出现什么情况?如何解决?
继承的成员方法访问问题
子类继承父类, 如果子类和父类的成员方法名称不一致,分别调用即可
如果如果一致,而且一模一样,方法重写Override (方法覆盖/方法复写),重写的时候必须要保证它的访问权限足够大!
class Fu{
public void show(){}
}
class Zi extends Fu{
void show(){ //不行,访问权限问题:要么跟父类的一模一样,要么永远带上public
}
}
多态成员特点（孔子装爹）：
匿名内部类(重点) :
匿名内部类: 没有名字的类
应用范围: 在局部位置中的(方法定义中或者声明上)
匿名内部类的格式:
new 类名或者一个接口名(){
重写方法(){
...
}
}
匿名内部类的本质:就是继承该类(抽象类)或者是实现类了该接口的子类对象
413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
