方法参数类型以及返回值问题
1.形式参数是基本类型要的是一个基本类型的变量或者具体的常量值;(1)是类名的时候要的是一个该类的对象;(2)是抽象类名的时候的要的是一个继承自该类的一个子类对象;(3)是接口的时候要的是一个实现了该接口的子类对象;
2.返回值是基本数据类型的时候返回的是一个具体的值;(1)是类名的时候,本质上返回的是一个该类对应的子类对象;(2)是抽象类名的时候返回的应该是一个继承自该类的子类对象;(3)是接口名的时候返回的是一个实现了该接口的子类对象;
3.注意:基本数据类型作为参数传递时,形参的改变不会影响实参,而引用数据类型作为参数传递时,形参的改变会影响实参!!!
链式编程
链式编程就是把多个方法使用点语法链接起来,只要结尾为一个对象就可以继续调用方法;
链式编程的优点:编程性强、可读性强、代码简洁;但是不太利于代码的调试;
普通写法:
Tiger tiger = new Tiger();
Tiger tiger1 = tiger.getTiger(new Tiger(), 10);
int age1 = tiger1.getAge();
链式编程:
int age = new Tiger().getTiger(new Tiger(), 10).getAge();
package、import
package为包的意思,本质为一个文件夹,包可以按照功能或者模块来划分,用来进行分类管理管理;
注意事项:(1)package语句必须是程序的第一条可执行的代码;(2)package语句在一个java文件中只能有一个(3)如果没有package,则默认表示无包名;
import:不同包下类之间的访问;
权限修饰符
四种权限修饰符:private(私有的) , 默认 , protected(受保护的) , public(公共的)
private :私有的只能在本类使用
默认:可以在本类和同一包下(子类和无关类使用
protected:可以在本类、同一个包下(子类和无关类)、不同包下(子类)
public:可以在所有情况下使用,包括不同包下
A:修饰符:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
B:可以修饰类的修饰符:
权限修饰符:默认修饰符,public
状态修饰符:final
抽象修饰符:abstract
用的最多的就是:public
C:可以修饰成员变量的修饰符:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
用的最多的就是:private
D:可以修饰构造方法:
权限修饰符:private,默认的,protected,public
用的最多的就是:public
E:可以修饰成员方法:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
用的最多的就是:public
F:除此以外的组合规则:
成员变量:public static final
成员方法:public static
public abstract
public final
内部类
内部类:即一个类中包含了另外一个类;
内部类的特点:1.内部类可以直接访问外部类的成员,包括私有;2.外部类要访问内部类的成员必须要创建对象
内部类分类:按照内部类位置分为:成员内部类和局部内部类
访问内部类成员格式:外部类名.内部类名 对象名=外部类对象.内部类对象
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(Outer2.this.num);//10//注意这种语法
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer2.Inner oi = new Outer2().new Inner();//直接访问内部类成员
oi.show();
}
}
成员内部类的修饰符:private:为了保证数据的安全性;static:为了方便访问数据;
注意事项:1.静态内部类访问外部类必须是静态的;2.成员方法可以是静态的也可以是非静态的;3.内部类的静态方法使用类名即可调用
成员内部类被静态修饰后的访问方式:外部类名.内部类名 对象名 = new 外部类名.内部类名();
static int num=100;
//static 可以修饰内部类
// 静态内部类只能访问外部类的静态成员
public static class NeiClass{
public void innerShow(){
System.out.println("我是内部类的show方法");
System.out.println(num);
hehe();
}
public static void innerTest(){
System.out.println("我是内部类的静态方法");
}
public void test(){
System.out.println("我是内部类的静态方法");
}
}
public static void hehe(){
System.out.println("我是外部类的静态hehe方法");
//内部类的静态方法,类名就可以调用
NeiClass.innerTest();
//外部类访问内部类的方法,创建内部类对象
NeiClass neiClass = new NeiClass();
neiClass.test();
}
}
public class Test4 {
public static void main(String[] args) {
//创建静态内部类的语法
WaiClass.NeiClass neiClass=new WaiClass.NeiClass();
neiClass.innerShow();
}
}
局部内部类访问局部变量必须使用final修饰;局部内部类可以直接访问外部类的成员;可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能
原因:因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
// 成员变量
private int a = 45;
// 成员方法
public void show() {
// 定义一个局部变量
final int b = 45;//JDK1.7之前要加final不然报错 但是在JDK1.8 不用加 不会报错
// 局部内部类
class Inner {
public void method() {
System.out.println(a);
System.out.println(b);
}
}
// 创建对象
Inner i = new Inner();
// 调用方法
i.method();
}
public static void main(String[] args) {
// 创建Outer的对象
Outer out = new Outer() ;
// 调用show方法
out.show() ;
}
}
匿名内部类
匿名内部类:就是局部内部类的简写方法;
匿名内部类的前提:存在一个类或者接口;这里的类可以是具体类也可以是抽象类;
书写格式:new 类名或者接口名{
重写方法;
}
匿名内部类的本质:是一个继承了类或者实现了接口的子类匿名对象;
public static void main(String[] args) {
//匿名内部类:他是局部内部类的简写方式
//匿名内部类本质是一个对象,是谁的对象呢?是实现了该接口或继承了该抽象类的子类对象
//匿名内部类的语法
new Animal() {
@Override
public void show() {
System.out.println("我重写了show方法");
}
}.show();
testMethod(new Animal() {
@Override
public void show() {
System.out.println("我又重写了show方法");
}
});
// testMethod(new Dog());
}
private static void testMethod(Animal an) {
an.show();
}
}