本文详细介绍了Java中的基本数据类型与引用数据类型的使用，包括变量定义、参数传递和返回值。强调了基本数据类型存储的是值，而引用数据类型存储的是对象的地址。同时，通过实例展示了类、抽象类和接口作为方法参数和返回值时的多态特性，强调了这些特性在代码扩展性和灵活性上的优势。
引用数据类型：
什么叫基本数据类型:4类8种 byte short int long float double char boolen
什么叫引用数据类型:数组,接口,String类,集合,自定义类型(Person,Student)
基本数据类型使用的是值
int a = 10; double d = 1.1;
引用数据类型:引用的都是堆内存中对象的地址值
引用数据类型使用的是对象的地址值
int[] arr = new int[10];
ArrayList<String> list = new ArrayList<>();
Student s = new Student();
Fly f = new MaQue(); 多态
String s = "abc"; //底层是一个数组 new char[]{'a','b','c'}
1.引用数据类型定义变量使用:
int a = 10; 基本数据类型赋值
数据类型 变量名 = 创建对象;
int[] arr = new int[10]; 赋值地址值
Student s = new Student(); 赋值地址值
ArrayList<String> list = new ArrayList<String>();赋值地址值
(接口)MyInter m = new MyInterImpl();赋值地址值
(抽象类)Animal a = new Cat(); 赋值地址值
2.引用数据类型作为方法的参数:
public static void method(int a){} 使用基本数据类型作为方法的参数 method(10)
public static void method(int[] a){}使用引用数据类型作为方法的参数 method(new int[10]);
public static void method(Student s){}使用引用数据类型作为方法的参数 method(new Student());
public static void method(ArrayList<String> list){}使用引用数据类型作为方法的参数
method(new ArrayList<String>())
public static void method(MyInter m){}使用引用数据类型作为方法的参数
method(new MyInterImpl1()) method(new MyInterImpl2()) method(new MyInter(){重写方法})
多态:MyInter m = new MyInterImpl1(); MyInter m = new MyInter(){重写方法}==>匿名内部类
public static void method(Animal a){}使用引用数据类型作为方法的参数
method(new Cat()) method(new Dog())
多态: Animal a = new Cat(); Animal a = new Dog();
3.引用数据类型作为方法的返回值类型:
public static int show(){ return 10;}
public static int[] show(){ return new int[10];}
public static Student show(){ return new Student();}
public static ArrayList<String> show(){ return new ArrayList<String>();}
public static MyInter show(){ return new MyInterImpl1();} //返回接口的不同实现类对象
public static MyInter show(){ return new MyInterImpl2();} //返回接口的不同实现类对象
public static Animal show(){ return new Cat();} //返回抽象类的不同子类对象
public static Animal show(){ return new Dog();} //返回抽象类的不同子类对象
4.引用数据类型作为成员变量:
public class Student{
private int a;
private int[] arr;
private Student stu;
private ArrayList<String> list;
private MyInter my;
private Animal animal;
//get和set方法,toString方法,构造方法
}
Student s = new Student();
s.setA(10);
s.setArr(new int[10]);
s.setStu(new Student());
s.setList(new ArrayList<String>());
s.setMyInter(new MyInterImpl());
s.setAnimal(new Cat());
总结:
1.基本数据类型能做什么事(定义变量,作为参数,作为返回值,定义成员变量),引用数据类型也能做
2.基本数据类型使用的值,引用数据类型使用的对象的地址值
1.类名作为方法参数和返回值类型1.类名作为方法参数和返回值类型
package com.itheima.demo03Test;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.itheima.demo03Test;
/*
类名作为方法参数和返回值类型
类名:Student
引用数据类型作为参数和返回值:传递的是对象的地址值,返回的也是对象的地址值
*/
public class Demo01Test {
public static void main(String[] args) {
Student s1 = new Student("张三",18);
System.out.println(s1);//@140e19d
//调用show方法,实参传递一个Student对象,给形参赋值
show(s1);//@140e19d
System.out.println("-------------------------");
//Student s4 = getStudent();=s3=@17327b6==>new Student("李四",20);
Student s4 = getStudent();
System.out.println(s4.getName()+"\t"+s4.getAge());//李四 20
}
/*
定义一个方法,方法的返回值类型使用Student
方法的返回值类型使用Student,方法中就需要返回一个Student对象(值)
方法的返回值类型使用int,方法中就需要返回一个整数10(值)
方法的返回值类型使用String,方法中就需要返回一个字符串"aaa"(值)
方法的返回值类型使用double[],方法中就需要返回一个数组对象 new double[10];(值)
*/
public static Student getStudent(){
Student s3 = new Student("李四",20);
System.out.println(s3);//@17327b6
return s3;//@17327b6
}
/*
定义一个方法,方法的形式参数类型使用Student
Student s2 = s1 = @140e19d==>new Student("张三",18);
*/
public static void show(Student s2){
System.out.println(s2.getName()+"\t"+s2.getAge());
}
}
2.抽象类作为方法参数和返回值类型
- 抽象类作为形参：表示可以接收任何此抽象类的"子类对象"作为实参；
- 抽象类作为返回值：表示"此方法可以返回此抽象类的任何子类对象"；
package com.itheima.demo04Test;
/*
抽象类作为方法参数和返回值类型
好处:扩展性强
使用抽象父类作为方法的形式参数:可以接收任意的子类对象(多态)
使用抽象父类作为方法的返回值类型:在方法中可以返回任意的子类对象(多态)
*/
public class Demo01Test {
public static void main(String[] args) {
//调用show方法,可以传递Animal的任意的子类对象
show(new Cat());
show(new Dog());
System.out.println("----------------------------");
/*
多态:
Animal a = getInstance() = new Cat();
Animal a = getInstance() = new Dog();
*/
Animal a = getInstance();
a.eat();
}
/*
定义一个方法,方法的返回值类型使用Animal
在方法中就可以返回Animal的任意子类对象
*/
public static Animal getInstance(){
//return new Cat();
return new Dog();
}
/*
定义一个方法,方法的参数使用Animal类型
多态:父类的变量指向了子类对象
Animal a = new Cat();
Animal a = new Dog()
*/
public static void show(Animal a){
a.eat();
}
}
package com.itheima.demo04Test;
public abstract class Animal {
public abstract void eat();
}
package com.itheima.demo04Test;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼!");
}
}
package com.itheima.demo04Test;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉!");
}
}
3.接口作为方法参数和返回值类型
- 接口作为方法的形参：可以传递接口的任意实现类对象
- 接口作为方法的返回值：可以返回接口的任意的实现类对象
package com.itheima.demo05Test;
/*
接口作为方法参数和返回值类型
好处:扩展性强
使用接口作为方法的形式参数:可以接收任意的实现类对象(多态)
使用接口作为方法的返回值类型:在方法中可以返回任意的实现类对象(多态)
*/
public class Demo01Test {
public static void main(String[] args) {
//调用show方法,传递Fly接口的任意的实现类对象,给Fly类型的变量赋值
show(new Niao());
show(new Ying());
System.out.println("---------------------");
/*
多态:
Fly f = getInstacne() = new Niao();
Fly f = getInstacne() = new Ying();
*/
Fly f = getInstacne();
f.fly();
}
/*
定义一个方法,方法的返回值类型使用Fly接口类型
在方法中就可以返回Fly接口任意的实现类对象
*/
public static Fly getInstacne(){
//return new Niao();
return new Ying();
}
/*
定义一个方法,方法的参数使用Fly接口类型
多态:
Fly f = new Niao();
Fly f = new Ying();
*/
public static void show(Fly f){
f.fly();
}
}
package com.itheima.demo05Test;
public interface Fly {
public abstract void fly();
}
package com.itheima.demo05Test;
public class Niao implements Fly {
@Override
public void fly() {
System.out.println("小麻雀在飞翔!");
}
}
package com.itheima.demo05Test;
public class Ying implements Fly {
@Override
public void fly() {
System.out.println("鹰击长空!");
}
}
扫一扫
7359
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
