|
马上注册,结交更多好友,享用更多功能^_^
您需要 登录 才可以下载或查看,没有账号?立即注册
x
学习视频:https://www.bilibili.com/video/BV17J411G72L?p=20
145-159
- /*
- *方法的参数传递机制:
- *实参 --> 形参
- *(1)形参是基本数据类型
- *实参赋值给形参是数据值,形参值的修改不影响实参
- *(2)形参是引用数据类型
- *实参赋值给形参的是地址值,如果形参修改了对象的属性值,那么实参对象的属性值也会修改
- *
- */
- class Test08_01{
- public static void main(String[] args){ //图1
- int x = 1, y = 2;
- swap(x, y);
- System.out.println(x + " " + y);//并为交换
- }
- public static void swap(int a, int b){
- int temp = a;
- a = b;
- b = temp;
- }
- }
- class Test08_02{
- public static void main(String[] args){ //图2
- Circle yuan = new Circle();
- yuan.radius = 1.0;
- doubleRadius(yuan);
- System.out.println(yuan.radius);
- }
- public static void doubleRadius(Circle c){
- c.radius *= 2;
- }
- }
- class Circle{
- double radius;
- }
- /*
- *方法的参数传递面试题陷阱
- *当形参是引用数据类型,实参给形参地址值之后,
- *形参修改了地址值,那么和实参就无关了
- */
- class Test08_02{
- public static void main(String[] args){
- Circle yuan = new Circle();
- yuan.radius = 1.0;
- doubleRadius(yuan);
- System.out.println(yuan.radius); //图3
- }
- public static void doubleRadius(Circle c){
- c = new Circle();//新增一句后,radius不扩大两倍了
- c.radius *= 2;
- }
- }
- class Circle{
- double radius;
- }
- /*
- *方法的重载
- *在同一个类中,出现两个或多个名称相同,形参列表不同,称为方法的重载
- *
- *为什么要有方法的重载?为了调用方便
- */
- class Test08_03{
- public static void main(String[] args){
- System.out.println(max(1, 3));
- System.out.println(max(2.0, 1.0));
- System.out.println(max(1, 3, 4));
- }
- //方法重载时,不去看返回值类型是否一致,只看方法名和形参列表
- //public static double max(int a, int b){
- //return a > b ? a : b;
- //}
- public static int max(int a, int b){
- return a > b ? a : b;
- }
- public static double max(double a, double b){
- return a > b ? a : b;
- }
- public static iny max(int a, int b, int c){
- int max = a > b ? a : b;
- max = max > c ? max : c;
- return max;
- }
- }
- /*
- *命令行参数:给main方法穿的实参(了解)
- */
- class Test08_04{
- public static void main(String[] args){
- for(int i = 0; i < args.length; i++){
- System.out.println(args[i]);//从键盘重传入
- }
- }
- }
- /*
- *可变参数:新参列表中出现了...
- *使用原则:(1)可以传入0-n个对应的实参,也可以传入对应数据类型的数组对象!!!!
- *(2)非可变参数的形参部分,原来该怎么传,现在还怎么传
- */
- class Test08_05{
- public static void main(String[] args){
- System.out.println(sum(1, 3, 4));
- System.out.println(max(1, 3, 4));
- System.out.println(max());//报错
- }
- public static int sum(int... n){//传入任意多个 和 int sum(int[] arr)这种不能同时定义!!!
- int sum = 0;
- for(int i = 0; i < nums.length; i++){
- sum += nums[i];
- }
- return sum;
- }
- //int num1 是非可变参数部分
- public static int max(int num1, int... nums){
- int max = num1;
- for(int i = 0; i < nums.length; i++){
- if(nums[i] > max){
- max= nums[i];
- }
- }
- return max;
- }
- }
- /*
- *变量的分类:
- *1.成员变量:这里讨论的是非静态的成员变量
- *2.局部变量
- *(1)声明的位置不同:成员在类的方法外;局部变量在{}中声明的或是在()中声明的形参
- *(2)运行时在内存中的位置也不同:成员变量在堆中,局部变量在栈中。
- *(3)初始化不同:成员变量如果没有初始化,有默认值;局部变量没有初始化,会报错、
- *(4)生命周期:成员变量(随着对象的创建而分配,随着对象被垃圾回收而回收)
- *局部变量(方法被调用,开始分配,方法执行结束就结束)
- *(5)可用的修饰符:成员变量(有很多,之后讲)局部变量(final,之后讲)
- */
- class Test08_06{
- public static void main(String[] args){
- String ming = "张三";//局部变量
- int nian = 23;//局部变量 //图4
- Student s1 = new Student();//s1是局部变量
- s1.name = ming;
- s1.age = nian;
- }
- }
- class Student{
- String name;//成员变量(在类中的方法外)
- int age;
- void set(String n, int a){//n是局部变量
- name = n;
- age = a;
- }
- }
- /*
- *对象数组!!!!!!!!!!!!!!!!!!!!!!!!!!!
- *
- */
- //错误写法
- class Test08_07{
- public static void main(String[] args){
- //用一个数组,存储5个圆对象,半径分别是1-5
- Circle[] arr = new Circle[5];
- for(int i = 0; i < arr.length; i++){ //图5
- arr[i].radius = i + 1;//null报错
- }
- for(int i = 0; i < arr.length; i++){
- arr[i].printInfo();
- }
- }
- }
- class Circke{
- double radius;
- double getArea(){
- return 3.14 * radius * radius;
- }
- void printInfo(){
- System.out.println(radius + " " + getArea());
- }
- }
- //正确写法
- class Test08_07{
- public static void main(String[] args){
- Circle[] arr = new Circle[5]; //图6
- for(int i = 0 i < arr.length; i++){
- arr[i] = new Circle();//新增一句
- arr[i].radius = i + 1;
- }
- for(int i = 0; i < arr.length; i++){
- arr[i].printInfo();
- }
- }
- }
- /*
- *面向对象的基本特征:
- *(1)封装
- *(2)继承
- *(3)多态
- */
- /*
- *封装:
- *(1)隐藏实现细节
- *(2)安全
- *封装的范围:
- *(1)属性的封装、方法的封装
- *(2)组件的封装
- *(3)系统的封装
- *封装的实现,靠权限修饰符
- * 本类 本包 其他包子类 任意位置
- *private: 1 0 0 0
- *缺省/省略 1 1 0 0
- *protected: 1 1 1 0
- *public: 1 1 1 1
- *类、属性、方法、构造器、内部类可以加修饰符
- *类:缺省、public(如果类前面有public则必须与源文件名相同)
- *属性:四种都可以(大多数用private,私有化会提供get/set方法)
- *方法:四种都可以(大多数是public)
- *
- */
- class Test08_08{
- public static void main(String[] args){
- Circle c1 = new Circle();
- c1.setRadius(1.2);
- System.out.printl(c1.getRadius());
- }
- }
- class Circle{
- private double radius;//仅限于本类中的访问
- //radius属性的set方法,修改值
- public void setRadius(double r){
- if(r > 0)radius = r;//使赋值可控
- }
- //radius属性的get方法,获取值
- public double getRadius(){//注意命名
- return radius;
- }
- }
- /*
- *构造器作用:(1)构造对象,创建对象 和new一起使用
- *(2)创建对象的同时给属性赋值
- *构造器的特点:(1)所有类都有构造器
- *(2)如果一个类没有显示声明构造器,那么编译器将会自动生成一个默认的无参构造
- *(3)如果一个类显示声明了构造器,那么编译器将不会自动生成默认的无参构造了
- *(4)构造器的名称必须与类名相同
- *(5)构造器没有返回值类型,不用写void!!!!!!!!
- *(6)构造器可以重载
- */
- class Test08_08{
- public static void main(String[] args){
- //创建对象
- Circle c1 = new Circle(1.2);//创建对象的同时给属性赋值
- c1.printInfo();
- c1.setRadius(2.5);//创建对象之后,修改属性值
- Circle c2 = new Circle();
- c2.setRadius(3.6);
- c2.printInfo();
- }
- }
- class Circle{
- private double radius;
- public Circle(double d){//有参构造
- radius = 0;
- }
- public Circle(){//无参构造
- }
- public void printInfo(){
- System.out.println(radius);
- }
- public void setRadius(double r){
- radius = r;
- }
- }
复制代码
|
|