参数类型
- 类名作为形式参数
public static void main(String[] args) {
//如果你以后看到一个方法的形参要一个类 类型你就传一个该类对象
Student student = new Student();
student.show(new Student(),20);
System.out.println(student.num);
}
}
class Student{
int num=100;
public void show(Student stu,int num){
stu.num=num;
}
}
- 抽象类名作为形式参数
public static void main(String[] args) {
//如果你以后看到一个方法的形参要一个 抽象类 类型,你就传一个该类的子类对象
Dog dog = new Dog();
setMethod(dog,114);
}
private static void setMethod(Animal an,int num) {
an.show(num);
}
}
abstract class Animal{
int num=110;
public abstract void show(int a);
}
class Dog extends Animal{
int num=20;
@Override
public void show(int num) {
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
- 接口名作为形式参数
public static void main(String[] args) {
//如果你以后看到一个方法的形参要一个 接口 类型 你就传一个该接口的子类对象
MyClass myClass = new MyClass();
test(myClass,22);
}
private static void test(MyInterface myInterface,int b) {
myInterface.show(b);
}
}
interface MyInterface{
int NUM=100;
void show(int a);
}
class MyClass implements MyInterface{
int b=10;
@Override
public void show(int a) {
System.out.println(this.b);
System.out.println(NUM);
System.out.println(MyInterface.NUM);
}
}
返回值类型
- 类名作为返回值类型
public static void main(String[] args) {
//如果你以后看到一个方法的返回值类型,要一个类 类型 你就返回一个该类对象
Student student = new Student();
student.num=20;
Student student1 = student.getStudent(new Student(),111);
System.out.println(student1.num);
System.out.println(student1==student);
}
}
class Student {
int num=10;
public Student getStudent(Student student,int num){
this.num=num;
Student student2 = new Student();
return this;
}
}
- 抽象类名作为返回值类型
public static void main(String[] args) {
Animal animal = getAnimal(new Cat());
animal.test();
}
//如果你以后看到一个方法的返回值类型,要一个抽象类 类型,你返回一个该抽象类的子类对象
private static Animal getAnimal(Cat cat) {
return cat;
}
}
abstract class Animal{
public abstract void test();
}
class Cat extends Animal{
@Override
public void test() {
System.out.println("abc");
}
}
- 接口名作为返回值类型
public class MyTest2 {
public static void main(String[] args) {
MyInterface anInterface = getInterface(10);
anInterface.show(1000);
}
//如果你以后看到一个方法的返回值类型,要一个 接口类型,你就返回一个该接口的子类对象
private static MyInterface getInterface(int num) {
num=11;
return new MyClass();
}
}
interface MyInterface{
void show(int num);
}
class MyClass implements MyInterface{
@Override
public void show(int num) {
System.out.println(num);
}
}
链式编程
当你调用完一个方法后,他的返回值又是个对象,那么你紧接着,就可以打点,在继续调用对象中的方法。
package关键字
- 包的概述:就是文件夹
- 包的作用:用来解决同一个路径下不能存在同名文件的问题(分类管理)
- 定义包的格式:package 包名;
多级包用.分开即可 - 定义包的注意事项:
package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package,默认表示无包名
import关键字
- 导包的概述:不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能。
- 导包格式 import 包名;
内部类
- 按照内部类位置分类
成员位置:在成员位置定义的类,被称为成员内部类。
局部位置:在局部位置定义的类,被称为局部内部类。 - 成员内部类
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象
成员内部类
- 成员内部类的修饰符:
private 为了保证数据的安全性
static 为了方便访问数据
注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的 - 成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();
局部内部类
- 可以直接访问外部类的成员
- 可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能
- 局部内部类访问局部变量必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。
为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
匿名内部类
- 匿名内部类: 就是局部内部类的简化写法。
- 前提: 存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
- 格式:
new 类名或者接口名(){
重写方法;
} ; - 本质是一个继承了该类或者实现了该接口的子类匿名对象。
public class MyTest {
public static void main(String[] args) {
new AA(){
@Override
public void show() {
System.out.println("ccccc");
}
}.show();
}
}
class AA{
public void show(){
System.out.println("abc");
}
}