本文共 5817 字,大约阅读时间需要 19 分钟。
1、封装一段特定的业务逻辑功能
2、尽可能的独立,一个方法只干一件事
3、可以反复调用多次
4、可以减少代码重复,有利于代码的维护和团队的协作
方法完成后:
1)若需要用到方法中的某个数据---------------------有返回值
2)若不需要用到方法中的某个数据-------------------无返回值(void)
System.out.println("Hello"); //换行输出 Arrays.sort(arr); // //数组排序 默认升序 System.arraycopy(a,1,a1,0,4); //数组复制 ----------------无返回值 double b = scan.nextDouble(); //接受用户输入的小数 double c = Math.random(); //计算随机数 int [] a1 = Arrays.copyOf(a,6); //数组复制 int a = scan.nextInt(); //接受用户输入的整数 ----------------有返回值 |
---|
方法的定义:五个要素:修饰词、返回值类型、方法名、参数列表、方法体
方法的调用:
public static void main(String [] args){ //主方法
say();//调第一个方法
say("TZZ",28);//调第二个方法
int b=num(5,6);
System.out.println(b); //调第四个方法
int m=5,n=6;
int c=num(5,6);
System.out.println(c); //调第四个方法
}
public static void say(){ //无返回值无参
System.out.println("大家好,我是TZZ,我今年28岁了")
}
public static void sayHi(String name,int age){ // 无返回值有参
System.out.println("大家好,我是"+name+",我今年"+age+"岁了")
}
public static double num(){ //有返回值无参
return(88.88);
}
public static int sum(int num1,int num2){ //有返回值有参
return(num1+num2);//也可以
int sum=num1+num2;
return(sum);//也可以
}
return:方法有返回值要跟return 值;return的作用是结束方法的执行;返回结果给调用方
0、方法的签名:方法名+参数列表
1、方法的重载 (Overload)
1)发生在一个类中,方法名称相同,参数列表不同,方法体不同
2)编译器在编译时根据方法的签名自动绑定调用的方法
2、构造方法
1)给成员变量赋初值,减少代码重复,在创建对象的时候
2)与类同名,没有返回值类型,无void
3)在创建(new)对象时被自动调用
4)若自己不写构造,则默认一个无参构造方法
若自己写了构造了,则不再默认提供了
5)构造方法可以重载
3、this
指代当前对象,哪个对象调用方法指的就是哪个对象
只能用在方法中,在方法中访问成员变量之前,默认都有个this.
当成员变量和局部变量同名时,this.不能省略
this的用法:
1)this.成员变量名---------访问成员变量
2)this.方法名()----------调用方法(一般不用)
3)this()------------------调用构造方法
1)作用:代码复用
2)通过extends来实现继承
3)超类/父类:所有派生类所共有的属性和行为
派生类/子类:派生类特有的属性和行为
4)派生类继承超类后,派生类具有:派生类的+超类的
5)一个超类可以有多个派生类
一个派生类只能有一个超类--------单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须先构造超类
在派生类的构造方法中,若没有调用超类的构造方法------则默认super()来调用超类的无参构造方法
在派生类的构造方法中,若调用了超类的构造方法---------则不再提供
class Student{ String name; int age; String address; int stuID; void eat(){} void sleep(){} void study(){} } | class Teacher{ String name; int age; String address; double salary; void eat(){} void sleep(){} void teach(){} } | class Teacher extends Person{ double salary; void teach(){} }
class Student extends Person{ int stuID; void study(){} } | class Person{ String name; int age; String address; void eat(){} void sleep(){} } |
---|---|---|---|
学生 类 | 教师 类 | 继承 | 人 类 |
派生类 | 派生类 | 继承 | 超类 |
指代当前对象的超类对象
super的用法:
1)super.成员变量名--------------------------访问超类的成员变量
2)super.方法名()-----------------------------访问超类的方法
3)super()--------------------------------------调用超类的构造方法
1)超类型的引用指向派生类的对象
2)能点出来什么,看引用的类型
1)发生在父子类中,方法名称相同,参数列表不同,方法体不同
2)重写方法被调用时,看对象的类型
1)重写:发生在父子类中,方法名称相同,参数列表相同,方法体不同
运行期绑定 看对象的类型来调用
2)重载:发生在一个类中,方法名称相同,参数列表不同,方法体不同
编译期绑定 看引用的类型来绑定
1)作用:避免类名的冲突
2)包名可以有层次结构,同包中的类不能同名
3)类的全称:包名.类名
4)建议:包名所有字母都小写
同包中的类可以直接访问,不同包中的问题不能直接访问,想访问有两种方式:
1)先import声明类再直接使用类----建议
2)类的全称--------------------------太繁琐,不建议
数据要加访问权限private-派生类/protected-超类,方法做成公开public
注意:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上四种都可以
1)静态变量:
1、由static修饰的
2、属于类的,存储在方法区中,只有1份
3、常常通过类名点来访问
4、何时用:所有对象所共享的数据(图片、音频、视频等)
2)静态方法:
1、由static修饰的
2、属于类的,存储在方法区中,只有1份
3、常常通过类名点来访问
4、静态方法没有隐式this传递,所以在静态方法中不能直接访问实例成员
5、何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
1、属于类的,在类被加载期间自动执行,类只被加载一次,所以静态块只执行一次
2、何时用:常常用于加载/初始化静态资源(图片、音频、视频等)
实例变量:没有static修饰的,属于对象的,存储在堆中
有几个对象就有几份
静态变量:由static修饰,属于类的,存储在方法区中
只有1份
由JVM来管理的
1)堆:存储new出来的对象(包括实例变量)
垃圾:没有任何引用指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾,回收过程是透明的(看不到的),不一定发现垃圾就立刻回收
调用System.gc()可以建议JVM尽快调度GC来回收
内存泄漏:不再使用的对象还没有被及时的回收
建议:对象不再使用时应及时将引用设置为null
实例变量的生命周期:从对象在堆中创建开始到对象从堆中被回收结束
2)栈:存储正在调用中的方法中的局部变量(包括方法参数)
调用方法时会为该方法在栈中分配一块对应的栈帧,栈帧中存储局部变量(包括方法参数)
当方法调用结束时,栈帧被清除,局部变量一并失效
局部变量的生命周期:调用方法时存储在栈中,方法结束时与栈帧一并被清除
3)方法区:存储.class字节码文件(包括方法、静态变量)
方法只有一份,通过this来区分具体的调用对象
成员变量和局部变量的区别:
1)必须声明的同时初始化
比如 puiblic static final double PI = 3.141592653
2)类名点来访问、不能被改变
3)建议:常量名所有字母都大写,多个单词之前用_分隔
4)编译器在编译时将常量直接替换为具体的值,效率高
5)何时用:该数据永远不变,并且经常使用
1)由abstract修饰
2)只有方法的定义,没有具体的实现,连{}都没有
比如public abstract step();
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
3)抽象类不能被实例化
4)抽象类是需要被继承的,派生类需重写抽象类中的所有抽象方法,否则也需声明为抽象类,但是这样做没有意义
5)抽象类的意义:
封装共有的属性和行为
为所有派生类提供统一的类型
可以包含抽象方法,为所有派生类提供统一的入口
1)将所有派生类共有的属性和行为,抽到超类中----------抽共性
2)派生类的行为都一样,设计为普通方法
派生类的行为都不一样,设计为抽象方法
3)将部分派生类所共有的行为,抽到接口中
符合既是也是原则时,需使用接口
接口是对继承单根性的扩展---------实现多继承
1)类中套类,外面的称为Outer外部类,里面的称为Inner内部类
2)内部类通常只服务于外部类,对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象 eg:外部类名.this
class Aoo{
class Boo{
}
}
1)若想创建一个类(派生类)的对象,并且对象只创建一个,此时该类不必命名,称为匿名内部类
2)在jdk1.8之前,匿名内部类中若想访问外面的变量,该变量必须是final的
//匿名内部类public class NstInnerClassDemo {public static void main(String[] args) {//1)创建了Coo的一个派生类,这个派生类没有名字//2)为该派生类创建了一个对象,名为o1//3)大括号中为派生类的类体,如果超类里有抽象方法,大括号里要有重写的操作Coo o1=new Coo() {};Doo o3=new Doo(){void show() {System.out.println("showshow");}};o3.show();}}abstract class Doo{abstract void show();}abstract class Coo{}
常见面试题:问:内部类有独立的.class吗?答:有
1)是一种数据类型(引用类型)
2)由interface定义
eg
interface inter{
}
3)只能包含常量和抽象方法
eg
interface inter{
int NUM=5; //默认含有public static final
void show(); //默认含有public abstract
}
4)接口不能被实例化 (不能new对象)
5)接口是需要被实现的,实现类/派生类
必须重新所有抽象方法
6)一个类可以实现多个接口,用逗号分隔
若又继承又实现时,应先继承后实现 eg : class Aoo extends inter1 implements inter2{}
7)接口可以继承多个接口 eg:interface inter extends inter1,inter2{}
1)多态的意义:
1.同一类型的引用指向不同对象时,有不同的实现
-------行为的多态:cut()、run()、step().......
2.同一个对象被造型为不同的类型时,有不同的功能
--------对象的多态:我、你、水
2)向上造型/自动类型转换:
1.超类型的引用指向派生类的对象
2.能造型成为的类型有:超类+所实现的接口
3.能点出来什么,看引用的类型
3)强制类型转换,成功的条件只有如下两种:
1.引用所指向的对象,就是该类型
2.引用所指向的对象,实现了该接口或继承了该类
4)强转时若不符合如上两个条件,则发生ClassCastException类型转换异常
建议在强转之前先通过instanceof来判断引用的对象是否是该类型
1)类:封装的是对象的属性和行为
2)方法:封装一段特定的业务逻辑功能实现
3)访问控制修饰符:封装的是具体的访问权限
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所特有的属性和行为
派生类:派生类所特有的属性和行为
3)单一继承、多接口实现、传递性
1)意义:
行为的多态(所有抽象方法都是多态的)
对象的多态(所有对象都是多态的)
2)向上造型、强制类型转换、instanceof判断
3)多态的表现形式
重写:根据对象的不同来表现多态
重载:根据参数的不同来表现多态
转载地址:http://hhlai.baihongyu.com/