方法参数类型以及返回值类型问题研究
权限修饰符
内部类
匿名内部类
面向对象(类名作为形式参数)
当一个方法的形参一个类 类型,你就传该类的对象
A:案例演示: 类名作为形式参数
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
test(student,20);
System.out.println(student.num);
student.show(student,150);
System.out.println(student.num);
}
public static void test(Student student,int num){
student.num=num;
}
}
class Student{
int num=200;
public void show(Student student,int num){
student.num=num;
}
}
面向对象(抽象类名作为形式参数)
当一个方法的形参要一个抽象类类型,就传一个该抽象类的子类对象。
A:案例演示: 抽象类名作为形式参数
public class MyTest {
public static void main(String[] args) {
son son = new son();
test(son,15);
}
public static void test(Teacher teacher, int num) {
teacher.num = num;
teacher.show(num);
}
}
abstract class Teacher {
int num = 100;
public abstract void show(int num);
}
class son extends Teacher{
int num=2;
@Override
public void show(int num) {
System.out.println(num);
}
}
面向对象(接口名作为形式参数)
当一个方法的形参要一个接口类型,就传一个该接口的子类对象
A:案例演示: 接口名作为形式参数
public class MyTest {
public static void main(String[] args) {
MyClass myClass = new MyClass();
test(myClass,60);
}
public static void test(Myinterface myinterface,int num){
myinterface.show(num);
}
}
interface Myinterface{
int num=200;
public abstract void show(int num);
}
class MyClass implements Myinterface{
int num=10;
public void show(int num){
System.out.println(this.num);
}
}
面向对象(类名作为返回值类型)
当一个方法的返回值类型要一个类类型,就返回一个该类对象
A:案例演示: 类名作为返回值类型
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.num=20;
Student student1=student.getStudent();
student1.num=30;
System.out.println(student.num);
System.out.println(student1.num);
}
}
class Student{
int num=10;
public Student getStudent(){
Student student = new Student();
return student;
}
}
面向对象(抽象类名作为返回值类型)
当一个方法的返回值类型要一个抽象类类型,就返回该抽象类的子类对象。
A:案例演示: 抽象类名作为返回值类型
public class MyTest3 {
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");
}
}
面向对象(接口名作为返回值类型)
当一个方法的返回值类型要一个接口类型,就返回该接口的子类对象。
A:案例演示: 接口名作为返回值类型
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);
}
}
面向对象(链式编程)
当调用一个方法后,这个方法的返回值是一个对象,那么就可以紧接着大点,再去调用这个对象的方法。
A:案例演示: 链式编程
public class MyTest {
public static void main(String[] args) {
/*Student student = new Student();
Student student1=student.getStudent(student,14)
student1.show();*/
int a=new Student().getStudent(new Student(),120).show().num;
System.out.println(a);
}
}
class Student{
int num=20;
public Student getStudent(Student student,int num){
student.num=num;
return new Student();
}
public Student show(){
// System.out.println(num);
return this;
}
}
面向对象(package关键字的概述及作用)
A:包的概述: 就是文件夹
B:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
按照功能
按照模块
面向对象(包的定义及注意事项)
A:定义包的格式
package 包名;
多级包用.分开即可
B:定义包的注意事项
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package,默认表示无包名
面向对象(import关键字的概述和使用)
A:导包的概述
不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能
B:导包格式
import 包名;
注意:
这种方式导入是到类的名称。
虽然可以最后写*,但是不建议。
面向对象(四种权限修饰符的测试)
A:案例演示
四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)
B:结论
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
面向对象(类及其组成所使用的常见修饰符)
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
面向对象(内部类概述和访问特点)
A:内部类概述: 把类定义在其他类的内部,这个类就被称为内部类。
举例:在类A中定义了一个类B,类B就是内部类。
B:内部类访问特点
a:内部类可以直接访问外部类的成员,包括私有。
b:外部类要访问内部类的成员,必须创建内部类的对象。
C:案例演示
内部类极其访问特点
public class MyTest {
public static void main(String[] args) {
Outer.Inner inner=new Outer().new Inner();
inner.neiTest();
}
}
class Outer{
int num=20;
private int a=200;
public void waiShow(){
System.out.println("外部类的show方法");
}
public void waiTest(){
System.out.println("外部类的私有方法");
}
class Inner{
int aa=20;
String hh="abc";
public void neiShow(){
System.out.println(num);
System.out.println(a);
waiShow();
waiTest();
}
public void neiTest(){
System.out.println("内部类的方法");
}
public void heh(){
Inner inner = new Inner();
System.out.println(inner.aa);
inner.neiTest();
}
}
}
面向对象(内部类分类及成员内部类的直接使用)
A:按照内部类位置分类
成员位置:在成员位置定义的类,被称为成员内部类。
局部位置:在局部位置定义的类,被称为局部内部类。
B:成员内部类
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
面向对象(成员内部类的常见修饰符及应用)
A:成员内部类的修饰符:
private 为了保证数据的安全性
static 为了方便访问数据
注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的
B:成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();
面向对象(局部内部类访问局部变量的问题)
A: 可以直接访问外部类的成员
B: 可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。
为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
面向对象(匿名内部类的格式和理解)
A:匿名内部类: 就是局部内部类的简化写法。
B:前提: 存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
C:格式:
new 类名或者接口名(){
重写方法;
} ;
D:本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。
E:案例演示
按照要求来一个匿名内部类
public class MyTest {
public static void main(String[] args) {
new MyInterface(){
@Override
public void show() {
System.out.println("show");
}
}.show();
}
}
interface MyInterface{
void show();
}
面向对象(匿名内部类的方法调用)
A:案例演示: 匿名内部类的方法调用
public class MyTest3 {
public static void main(String[] args) {
Father father= new Father(){
@Override
public void hehe() {
System.out.println("呵呵");
}
@Override
public void haha() {
System.out.println("哈哈");
}
};
father.haha();
father.hehe();
}
}
abstract class Father{
public abstract void hehe();
public abstract void haha();
}