1.方法参数类型以及返回值类型问题研究
1.01方法参数类型
1.类名作为形式参数
当你以后看到一个方法的形参要一个 类 类型,你就传递一个该类的对象。
public static void main(String[] args) {
Student student = new Student();
set(student, 60);
student.show(new Student(), 80);//如果新new的new Student()没有进行实例化,就不会执行。
System.out.println(student.num); //运行结果:60
}
public static void set(Student student, int num)
{
student.num = num;
}
}
class Student {
int num = 20;
public void show(Student student, int num) {
student.num = num;
//this 代表那个调用者
//this.num=90;
}
}
2.抽象类名作为形式参数
当你以后看到一个方法的形参要一个抽象类 类型,你就传递一个该抽象类的子类对象。
public static void main(String[] args) {
//当你以后看到一个方法的形参要一个抽象类 类型,你就传递一个该类的 子类对象。
Cat cat = new Cat();
set(cat, 100);//传参
cat.show(500);
System.out.println(cat.num);//
}
public static void set(Animal animal, int num) {//方法的形参要一个抽象类
animal.num = num;
// ((Cat) animal).num=num;
}
}
abstract class Animal {
int num = 50;
public abstract void show(int num);
}
class Cat extends Animal {
int num = 60;
@Override
public void show(int num) {
super.num = num;
this.num=num;
}
}
3.接口名作为形式参数
你以后看到一个方法的形参要一个接口 类型 ,你就传递一个该接口的子类对象。
public class Mytest {
public static void main(String[] args) {
//当你以后看到一个方法的形参,要一个接口 类型,你就传递一个接口的子类对象。
MyClass myClass = new MyClass();
set(myClass,400);
System.out.println(myClass.num); //400
System.out.println(MyInterface.num); //2000
}
public static void set(MyInterface myInterface,int num){
myInterface.show(num);
}
}
interface MyInterface {
public static final int num=2000;//接口默认常量
void show(int num);
}
class MyClass implements MyInterface{
int num=2;
@Override
public void show(int num) {
this.num=num;
}
}
1.02返回值类型
1.类名作为返回值类型
当你以后看到一个方法的返回值类型,是一个类 类型,你就返回一个该类的对象。
public static void main(String[] args) {
Student stu = getStudent();//返回一个该类的对象。
Student stu1 = stu.getStu();
System.out.println(stu==stu1);//ture
System.out.println(stu1.num);//30
System.out.println(stu.num);//30
}
public static Student getStudent() {
Student student = new Student();
student.num = 20;
return new Student();
}
}
class Student {
int num = 30;
public Student getStu() {
return this;
}
}
2.抽象类名作为返回值类型
当你以后看到一个方法的返回值类型是一个抽象类 类型,你就返回一个该抽象类的子类对象。
public static void main(String[] args) {
Animal an = getAnimal();
an.num = 600;
System.out.println(an.num);//600
//向下转型
Animal animal=new Dog();
Dog dog= (Dog) an;
System.out.println(dog.num);//70
//向下转型
//Dog dog = (Dog) getAnimal();
}
//当你以后看到一个方法的返回值类型,要一个抽象类 类型,你要返回一个该类的子类对象。
public static Animal getAnimal() {
Dog dog = new Dog();
dog.num=70;
return dog;
}
}
abstract class Animal {
int num=20;
}
class Dog extends Animal {
int num=100;
}
3.接口名作为返回值类型
当你以后看到一个方法的返回值类型是一个接口 类型,你就返回一个该接口的子类对象。
public class Mytest {
public static void main(String[] args) {
Plusx a=getPlusx();
System.out.println(Plusx.num);//常量可以直接用接口名调用
System.out.println(a.num);
}
public static Plusx getPlusx(){
return new X();
}
}
interface Plusx{
int num=333;
}
class X implements Plusx{
int num=777;
}
4.链式编程
当你调用完一个方法后,他返回一个对象,那你就可以紧接着打点,再去调用这个对象所属类中的方法。
Student stu= getStu();
Student stu2=stu.getStudent();
int add = stu2.add(20, 30);
System.out.println(add);
//链式编程的语法风格:当你调用完一个方法后,他返回一个对象,那你就可以紧接着打点,再去调用这个对象所属类中的方法。
//int add = getStu().getStudent().add(60, 30);
System.out.println(add);
1
2
3
4
5
6
7
5.package关键字的概述及作用
1.包的概述: 就是文件夹
2:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
3:包的划分:
按照功能
按照模块
6.包的定义及注意事项
1.定义包的格式
package 包名;
多级包用.分开即可
2.定义包的注意事项
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package,默认表示无包名
7.不同包下类之间的访问
定义两个类:Demo,Test。
Demo
求和方法(sum)
Test
测试方法(main)
8.import关键字的概述和使用
导包的概述
不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能
B:导包格式
import 包名;
注意:
这种方式导入是到类的名称。
虽然可以最后写*,但是不建议。
package,import,class有没有顺序关系(面试题):
有顺序呢,package是第一句,import在中间,class在最后。import和class可以多句,但package只有一句。
2.权限修饰符
2.01四种权限修饰符的测试
四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)
结论
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
2.02类及其组成所使用的常见修饰符
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.01内部类概述和访问特点
1.内部类概述:
把类定义在其他类的内部,这个类就被称为内部类。
举例:在类A中定义了一个类B,类B就是内部类。
class B {
//成员内部类
class A {
}
public void show() {
//局部内部类
class C {
}
}
}
2.内部类访问特点
a:内部类可以直接访问外部类的成员,包括私有。
b:外部类要访问内部类的成员,必须创建对象。
public class MyTest {
public static void main(String[] args) {
Outer.Inner inner=new Outer().new Inner();
inner.neiShow();
}
}
class Outer {
int num = 10;
private int a = 20;
class Inner {
int nei = 200;
public void neiShow() {
System.out.println("内部类的成员方法");
System.out.println(num);
System.out.println(a);
System.out.println(nei);
waiShow();
waiTest();
}
public void neiTest() {
System.out.println("内部类的成员test方法");
}
}
public void waiShow() {
System.out.println("外部类的成员方法");
}
private void waiTest() {
System.out.println("外部类私有的成员方法");
}
public void hehe(){
Inner inner = new Inner();//重点
System.out.println(inner.nei);
inner.neiTest();
}
}
3.02内部类分类及成员内部类的直接使用
1.按照内部类位置分类:
成员位置:在成员位置定义的类,被称为成员内部类。(类中方法外)
局部位置:在局部位置定义的类,被称为局部内部类。(方法中)
2.成员内部类:
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Wai.Nei nei=new Wai().new Nei();
1.内部类,可以使用private来修饰
class Wai {
private class Nei {
public void neiShow() {
System.out.println("内部类的方法");
}
}
私有的内部类,外界无法创建其对象。Wai.Nei nei=new Wai().new Nei();
static,静态内部类,静态内部类,只能访问外部类的静态成员,不能访问非静态成员。
public class MyTest {
public static void main(String[] args) {
//创建静态内部类的语法
Outer.Inner inner=new Outer.Inner();
}
}
class Outer {
static int num=20;
//内部类,可以使用static来修饰
static class Inner {
public void neiShow(){
System.out.println(num);
hehe();
}
}
public static void hehe(){
}
}
3.03成员内部类的常见修饰符及应用
public class MyTest {
public static void main(String[] args) {
//1.内部类都能直接访问外部类的成员,包括私有成员。
//2.成员内部类,外界没有其创建对象的语法。
Wai wai = new Wai();
wai.show();
}
}
class Wai{
int num=20;
private int age=30;
class Inner{
}
public void show(){
//局部内部类
class Nei{
int b=1;
public void neiTest(){
System.out.println(num);
System.out.println(age);
test();
}
public void neiShow(){
System.out.println("nei show");
}
}
Nei nei = new Nei();
nei.neiShow();
}
private void test(){
System.out.println("外部类的私有方法");
}
public void hehe(){
//Nei nei=new Nei();
//Inner inner = new Inner();
show();
}
}
3.04局部内部类访问局部变量的问题
1.可以直接访问外部类的成员
2.可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能
3:局部内部类访问外部类局部变量(方法内的形参)必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。
为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
JDK1.8之后,final会默认加上,你不用手动去加,但是你要知道
4.匿名内部类
4.01匿名内部类的格式和理解
1.匿名内部类:就是局部内部类的简化写法。
B:前提:存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
C:格式:
new 类名或者接口名(){
重写方法;
} ;
D:本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。
public class MyTest {
public static void main(String[] args) {
//匿名内部类:他是局部内部类的一种简写形式。
//语法格式:new 接口名/类名(){重写方法}
//匿名内部类的本质:匿名内部类本质上是一个对象,是谁的对象,是实现了该接口或者继承了该抽象类的子类对象。
// A a = new A();
new MyClass(){
@Override
public void show() {
System.out.println(“重写了父类的抽象方法”);
}
}.show();
}
}
abstract class MyClass {
public abstract void show();
}
class A extends MyClass{
@Override
public void show() {
}
}
public class MyTest2 {
public static void main(String[] args) {
/* B b = new B();
b.show();*/
//匿名内部类:本质上是一个对象,是谁的对象呢?是实现了该接口或继承了该抽象类的子类对。
new MyInterface(){
@Override
public void show() {
System.out.println(“aaaa”);
}
};
new MyInterface() {
@Override
public void show() {
System.out.println("bbb");
}
}.show();
new MyInterface() {
@Override
public void show() {
System.out.println("ccc");
}
}.show();
}
}
interface MyInterface{
void show();
}
/*
class B implements MyInterface{
@Override
public void show() {
System.out.println("abc");
}
}
*/
4.02匿名内部类在开发中的应用
1.匿名内部类经常可以作为参数来传递。比较方便
2.匿名内部类,作为返回值来返回
//匿名内部类,作为返回值来返回
public static Myinterface getInstance() {
return new Myinterface() {
@Override
public void aa() {
System.out.println(“aaaaaaaaaaaaaaaaa”);
}
};
}
//匿名内部类,作为返回值来返回
public static Animal getInstance2() {
Animal an = new Animal() {
@Override
public void sleep() {
System.out.println("天天睡觉");
}
};
return an;
}
}
interface Myinterface {
void aa();
}
abstract class Animal {
public abstract void sleep();
}
3.在外界可以采用内部类的方式,创建出内部接口的子类对象。
public class MyTest {
public static void main(String[] args) {
//在外界可以采用内部类的方式,创建出内部接口的子类对象。
AA.BB b = new AA.BB() {
@Override
public void bb() {
System.out.println(“bbbbbbbbbbbbbbb”);
}
};
}
}
//在一个类里面可以定义一个接口。
class AA {
//内部接口 内部接口 可以私有,私有后外界就无法创建其子类对象。
interface BB {
void bb();
}
}
匿名内部类具有一系列的限制:
1.不能具有static成员域和成员函数和类。
2.不能具有static final修饰的引用类型。
3.不能具有s自定义的构造函数
4.不能具有静态代码块。
5.匿名内部类不能具有类修饰符。
4.03匿名内部类中this关键字
interface Inter {
public static final int a = 23 ;
}
public class Test {
public static void main(String[] args) {
new Inter() {
public void show() {
//this 代表匿名内部类
System.out.println(this.a);//23
}
}.show();
}