1 方法参数类型以及返回值类型问题研究
1.1 类名作为形式参数
当你以后看到一个方法的形参要一个 类 类型，你就传递一个该类的对象。
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
show(new Student(), 20);
student.setNum(40);
System.out.println(student.num);
}
public static void show(Student student, int num) {
student.num = num;
}
}
class Student {
int num = 100;
public void setNum(int num) {
this.num = num;
}
}
1.2 抽象类名作为形式参数
当你以后看到一个方法的形参要一个抽象类 类型，你就传递一个该抽象类的子类对象
public class MyTest2 {
public static void main(String[] args) {
BB bb = new BB();
show(bb, 50);
System.out.println(bb.num);
bb.aa();
}
public static void show(AA aa, int num) {
aa.num = num;
}
}
abstract class AA {
int num = 100;
public abstract void aa();
}
class BB extends AA {
int num = 20;
@Override
public void aa() {
System.out.println(super.num);
}
}
1.3 接口名作为形式参数
当你以后看到一个方法的形参要一个接口 类型 ，你就传递一个该接口的子类对象。
public class MyTest {
public static void main(String[] args) {
MyClass myClass = new MyClass();
show(myClass);
myClass.setNum(500);
System.out.println(myClass.num);
System.out.println(MyInterface.num);
}
public static void show(MyInterface myInterface) {
System.out.println(myInterface.num);
}
}
interface MyInterface {
public static final int num = 100;
void aa();
}
class MyClass implements MyInterface {
int num = 20;
public void setNum(int num) {
this.num = num;
}
@Override
public void aa() {
System.out.println(num);
}
}
1.4 类名作为返回值类型
当你以后看到一个方法的返回值类型，是一个类 类型，你就返回一个该类的对象。
public class MyTest {
public static void main(String[] args) {
Student student = getStudent();
student.setNum(80);
int num = student.getNum();
System.out.println(num);
}
public static Student getStudent() {
Student student = new Student();
student.num = 50;
return new Student();
}
}
class Student {
int num = 20;
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
1.5 抽象类名作为返回值类型
当你以后看到一个方法的返回值类型是一个抽象类 类型，你就返回一个该抽象类的子类对象。
public class MyTest2 {
public static void main(String[] args) {
CC cc = test();
cc.num = 500;
cc.cc();
System.out.println(cc.num);
}
public static CC test() {
MyClass myClass = new MyClass();
myClass.num = 120;
return myClass;
}
}
abstract class CC {
int num = 20;
public abstract void cc();
}
class MyClass extends CC {
int num = 10;
@Override
public void cc() {
System.out.println(num);
}
}
1.6 接口名作为返回值类型
当你以后看到一个方法的返回值类型是一个接口 类型，你就返回一个该接口的子类对象
public class MyTest3 {
public static void main(String[] args) {
Myinterface myinterface = test(8);
System.out.println(myinterface.num);
System.out.println(Myinterface.num);
BB bb = (BB) myinterface;
System.out.println(bb.num);
}
public static Myinterface test(int num) {
BB bb = new BB();
bb.num = num;
return bb;
}
}
interface Myinterface {
int num = 100;
public abstract void show(int num);
}
class BB implements Myinterface {
int num = 20;
@Override
public void show(int num) {
System.out.println(num);
}
}
1.7 链式编程
public class MyTest {
public static void main(String[] args) {
int num = new Student().getStudent(new Student(), 800).getStudent(new Student(), 9000).getNum();
System.out.println(num);
}
}
class Student {
int num = 10;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public Student getStudent(Student student, int num) {
student.num = num;
Student student1 = new Student();
student1.setNum(900);
return student;
}
}
1.8 package关键字的概述及作用
A:包的概述: 就是文件夹
B:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
按照功能
按照模块
1.9 包的定义及注意事项
A:定义包的格式
package 包名;
多级包用.分开即可
B:定义包的注意事项
a:package语句必须是程序的第一条可执行的代码
b:package语句在一个java文件中只能有一个
c:如果没有package，默认表示无包名
1.10 不同包下类之间的访问
A:导包的概述
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
B:导包格式
import 包名;
注意：
这种方式导入是到类的名称。
虽然可以最后写*，但是不建议。
2 权限修饰符
2.1 四种权限修饰符的测试
四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)
2.2 类及其组成所使用的常见修饰符
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
3 内部类
3.1 内部类概述和访问特点
A:内部类概述: 把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。
B:内部类访问特点
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。
3.2 内部类分类及成员内部类的直接使用
A:按照内部类位置分类
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
B:成员内部类
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
3.3 成员内部类的常见修饰符及应用
A:成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的
B:成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();
3.4 局部内部类访问局部变量的问题
A: 可以直接访问外部类的成员
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
JDK1.8之后，final会默认加上，你不用手动去加，但是你要知道
4 匿名内部类
4.1 匿名内部类的方法调用
public class MyTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
/*
* new 类名或者接口名(){
重写方法;
} ;
* */
new Animal() {
@Override
public void eat() {
System.out.println("吃饭");
}
};
new Animal() {
@Override
public void eat() {
System.out.println("吃饭222222");
}
}.eat();
}
}
abstract class Animal {
public abstract void eat();
}
class Dog extends Animal {
@Override
public void eat() {
System.out.println("asdfasdfasdf");
}
}
4.2 匿名内部类在开发中的应用
首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，
我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，
所以，可以使用匿名内部类改进以前的做法。
扫一扫
808
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
