文章目录
1.传参和返回值类型
1.1 形参
- 类名作为形式参数时,你就传一个该类对象
public class MyDemo {
public static void main(String[] args) {
Student student = new Student();
//当你形参是一个类名时,你就传一个该类对象
student.show(student);
}
}
class Student{
public void show(Student student){}
}
- 抽象类作为形式参数时,你就传一个抽象类的子类对象
public class MyDemo2 {
public static void main(String[] args) {
Dog dog = new Dog();
//如果方法的形参是一个抽象类时,你就传一个抽象类的子类对象
setshow(dog);
}
private static void setshow(Animal an) {
}
}
abstract class Animal{} //抽象类
class Dog extends Animal{} //抽象类的子类
- 接口作为形式参数时,你就传一个接口的子类对象
public class MyDemo3 {
public static void main(String[] args) {
Zi zi = new Zi();
//如果形参是一个接口时,你就传一个接口的子类对象
setmethod(zi);
}
private static void setmethod(Inter inter) {
}
}
interface Inter{} //接口
class Zi implements Inter{} //接口子类
1.2 返回值类型
- 如果一个方法的返回值类型,要一个类 类型 你就返回一个该类对象
public class MyDemo {
public static void main(String[] args) {
Student student = new Student();
}
}
class Student{
//如果一个方法的返回值要一个 类 类型,你就返回一个该类的子类对象
public Student show(Student student){
return student;//返回子类对象
}
}
- 如果一个方法的返回值类型要一个 抽象类 类型,你就传一个抽象类的自诶对象
public class MyDemo2 {
public static void main(String[] args) {
Dog dog = new Dog();
setMethod(dog);
}
//如果一个方法的返回值类型要一个抽象类 类型,你就传一个抽象类的子类对象
private static Animal setMethod(Dog dog) {
return dog;//返回子类对象
}
}
abstract class Animal{}
class Dog extends Animal{}
- 如果一个方法的返回值类型要一个接口 类型,你就传一个接口的子类对象
public class MyDemo3 {
public static void main(String[] args) {
Myclass myclass = new Myclass();
setMethod(myclass);
}
//一个方法的返回值是接口类型,你就传一个接口的子类对象
private static MyInterface setMethod(Myclass myclass) {
return myclass; //返回一个接口的子类对象
}
}
interface MyInterface{}
class Myclass implements MyInterface{}
1.3 链式编程
链式编程可以更加简便的调用方法。
链式编程就是当你调用完一个方法,其返回值还是个对象时,你就可以继续打点调用方法。
例:
public class MyDemo4 {
public static void main(String[] args) {
Student student = new Student();
int t = student.show(new Student()).test(20);//链式编程
System.out.println(t);
}
}
class Student{
public Student show(Student student){
return student;
}
public int test(int num){
return num;
}
}
调用student的第一个对象时,返回值还是一个对象,所以可以继续打点调用test方法,test方法返回值时具体数值,可以用int来收。
2.导包
包就是一个文件夹
作用:来解决同一个路径下不能存在同名文件的问题。
格式:package 包名
注意事项:
- package语句必须是程序的第一条可执行的代码。
- package语句在java文件中只能有一个。
- 如果没有package,默认不是无包名。
导包:可以在另外一个包下访问此包的成员。
格式:import 包名
package org.westos.demo7;//package是程序第一条可执行代码
import org.westos.demo6.Teacher;//导入demo6的Teacher类,可以在demo7中使用Teacher创建对象
public class MyTest {
public static void main(String[] args) {
Teacher teacher = new Teacher();
}
}
注意:package、import、class顺序是package第一条,import第二条,class第三条。
3.权限修饰符
四种权限修饰符
private(私有的) ,默认,protected(受保护的),public(公共的)
结论:
本类 | 同一包下(子类和无关类) | 不同包下(子类) | 不同包下(无关类) | |
---|---|---|---|---|
private | yes | |||
默认 | yes | yes | ||
protected | yes | yes | yes | |
public | yes | yes | yes | yes |
修饰符:
- 权限修饰符:private,默认的,protected,public
- 状态修饰符:static,final
- 抽象修饰符:abstract
修饰类的关键字:默认修饰符,public,final,abstract。
修饰成员变量的关键字:private,默认的,protected,public,static,final
修饰构造方法的关键字:private,默认的,protected,public
修饰成员方法的关键字:private,默认的,protected,public,static,final,abstract
4.内部类
定义:把类定义在其他类 的内部,这个类就是内部类
内部类访问特点:
- 内部类可以直接访问外部类的成员,私有的也可以。
- 外部类要访问内部类的成员,必须创建对象。
按照内部类位置分类:
- 成员位置:在成员位置定义的类,称为成员内部类。
- 局部位置:在局部位置定义的类,称为局部内部类。
4.1 成员内部类
在测试类中之直接访问成员内部类的成员
格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;
public class MyTest {
public static void main(String[] args) {
A.B b = new A().new B(); //创建内部类的对象
b.show();
}
}
class A{
int num=40;
private int num2=30;
class B{
public void show(){
System.out.println(num);
System.out.println(num2); //可以直接调用外部类的私有成员
aa();
}
}
public void aa(){
System.out.println("外部类方法");
}
}
4.2 成员内部类的常见修饰符
- private 为了保证数据的安全性
- static 为了方便访问数据
案例演示private:
public class MyDemo {
public static void main(String[] args) {
//Wai.Nei nei = new Wai().new Nei();私有化内部类,你不能在外界创建对象了
//但是可以在外部类中创建内部类对象,因为private可以在本类中使用
//在外界创建外部类对象,调用外部类方法就可以调用到内部类成员
Wai wai = new Wai();
wai.show();
}
}
class Wai{
private class Nei{
int num=30;
public void Neibu(){
System.out.println("内部类的方法");
}
}
public void show(){
Nei nei = new Nei();
System.out.println(nei.num);
nei.Neibu();
}
}
用static修饰的内部类在创建内部类的对象时的格式更加简洁
外部类名.内部类名 对象名 = new 外部类名.内部类名();
注意事项:用static修饰内部类之后,内部类只能访问外部类的静态成员或静态成员方法。
4.3 局部内部类
局部内部类就是在外部类的局部位置。
局部内部类不能直接在外界创建对象。
可以使用代码来表示局部内部类的用法
public class MyDemo2 {
public static void main(String[] args) {
Waibu waibu = new Waibu();//在外界创建外部类对象,来调用show()方法,来实现调用内部类成员
waibu.show();
}
}
class Waibu{
public void show(){
class Neibu{
int num=20;
public void test(){
System.out.println("内部类方法");
}
}
//需要在外部类的局部位置创建内部类对象
Neibu neibu = new Neibu();
neibu.test();
System.out.println(neibu.num);
}
}
注:局部内部类访问局部变量
class Outer{
public void show(){
int num=20;
class Inner{
//num=30;//此时num不能重新赋值
// 因为定义局部内部类后,外部类局部变量就用final修饰了,变成了常量。
}
}
}
5.匿名内部类
匿名内部类:局部内部类的简化写法
前提:存在一个类或者接口(类可以使具体类也可以是抽象类)
格式:
new 类名或者接口名(){
重写方法;
} ;
本质:本质上是一个对象,这个对象就是接口/类名的一个子类对象。
可以使用代码演示基本匿名内部类:
public class MyDemo {
public static void main(String[] args) {
//new Animal(){}就是Animal抽象类的子类对象
new Animal() {
@Override
public void show() {
System.out.println("重写show方法");
}
}.show();
//new Myinterface(){}就是Myinterface接口的子类对象
new Myinterface() {
@Override
public void test() {
System.out.println("重写test方法");
}
}.test();
}
}
abstract class Animal{ //抽象类
public abstract void show();
}
interface Myinterface{ //接口
void test();
}
还有就是一个匿名内部类怎么调用两个方法,不能直接调用两个方法,否则不是同一个子类对象。这是可以给整个匿名子类对象起一个名字。
MyInter myInter=new MyInter() {
@Override
public void show() {
}
@Override
public void test() {
}
};
//调用两个对象,而且使用同一个子类对象调用的
myInter.show();
myInter.test();
还有就是传参和返回值类型可以使用匿名内部类
传参可以直接使用匿名内部类传:
public class MyTest {
public static void main(String[] args) {
setMyInter(new MyInterface() { //调用方法
@Override
public void show() {
System.out.println("show方法重写了");
}
});
}
//形参是interface类型,使用匿名内部类直接传
private static void setMyInter(MyInterface myInterface) {
myInterface.show();
}
}
interface MyInterface{
void show();
}
返回值类型:
public class MyTest2 {
public static void main(String[] args) {
setMethod();
}
//返回值类型是一个接口类型,返回一个接口类型的子类对象
private static Myinter setMethod() {
//返回一个接口的子类对象
return new Myinter() {
@Override
public void show() {
System.out.println("show方法执行了");
}
};
}
}
interface Myinter{
void show();
}
5.1 类中定义接口
可以在类中定义一个接口
public class MyTest {
public static void main(String[] args) {
//给接口的匿名子类对象起个名字
Outer.MyInterface myInterface=new Outer.MyInterface() {
@Override
public void show() {
System.out.println("重写show方法");
}
};
myInterface.show();//用名字调用show方法
}
}
class Outer{
interface MyInterface{
void show();
}
}