匿名对象
理解：创建对象时，没有显式地赋予一个变量名，即匿名对象
特征：匿名对象只能调用一次
package com.atguigu.exer;
public class Text {
public static void main(String[] args) {
Phone p = new Phone();
System.out.println(p);
new Phone().sendEmail();
new Phone().price = 109;
new Phone().showPrice();
}
}
class Phone{
double price;//价格
public void sendEmail() {
System.out.println("发邮件");
}
public void showPrice() {
System.out.println("价格为：" + this.price);
}
}
结果
也可以这样用：
class phoneMall{
public void show(Phone phone) {
phone.sendEmail();
}
}
phoneMall phoneM= new phoneMall();
phoneM.show(new Phone());
方法的重载
在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可
如：
sort(int a)
sort(int a,int b)
sort(String a)
package com.atuguigu.java1;
public class OverLoad {
//反转数组
public void reverse(int[] arr) {
for(int i = 0;i < arr.length/2;i++) {
int temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
}
public void reverse(double[] arr) {
for(int i = 0;i < arr.length/2;i++) {
double temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
}
}
在调用时：
package com.atuguigu.java1;
public class OverLoadText {
public static void main(String[] args) {
OverLoad o = new OverLoad();
int[] a = new int[] {1,2,4,56,7,8,9};
double[] b = new double[] {0.4,0.8,434.23,45.32,34.90};
o.reverse(a);
o.reverse(b);
for(int i = 0;i < a.length;i++) {
System.out.println(a[i]);
}
System.out.println();
for(int i = 0;i < b.length;i++) {
System.out.println(b[i]);
}
}
}
a和b是两种不同的数组类型，但通过重载便可调用相同方法
可变个数形参的方法
可变个数形参的格式：数据类型…变量名
当调用可变个数形参的方法是，传入的参数个数可以是 ，0个，1个，2个。。。（使用方法跟数组一样）
可变形参的方法与本类中的方法名相同，形参不同的方法之间构成重载
可变个数形参在方法中必须声明在末尾
可变个数形参在方法的形参中，最多只能声明一个
package com.atuguigu.java1;
public class OverLoad {
public void show(int a) {
System.out.println(23);
}
public void show(String s) {
System.out.println("String s");
}
public void show(String ... strs) {//必须写在public void show(String s) 后面（最末尾）
System.out.println("String...strs");
}
}
package com.atuguigu.java1;
public class OverLoadText {
public static void main(String[] args) {
OverLoad tLoad = new OverLoad();
tLoad.show(122);//23
tLoad.show("43");//String s
tLoad.show("343","ew");//String...strs
}
}
值传递机制
参数是基本数据类型，实参赋给形参的是实参真实存储的数据值
参数是引用数据类型：实参赋给形参的是实参存储数据的地址值
例子：画以下内存图
在这里插入图片描述
例题：
（1）
package com.atuguigu.java1;
public class Circle {
double radius;
public double findArea() {
return Math.PI * this.radius * this.radius;
}
}
package com.atuguigu.java1;
public class PassObject {
public void printAreas(Circle c,int time) {
System.out.println("Radius" + "\t" + "Area");
for(int i = 1;i <= time;i++) {
c.radius = i;
System.out.println(i+"\t" + c.findArea());
}
}
}
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
Circle c = new Circle();
PassObject p = new PassObject();
p.printAreas(c,4);
}
}
结果:
(2)递归：求100的和：
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
MainFunction f = new MainFunction();
int sum = f.DiGui(100);
System.out.println(sum);
}
public int DiGui(int i) {
if(i == 1) {
return i;
}else {
return i + DiGui(i-1);
}
}
}
（3）
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
MainFunction f = new MainFunction();
int result = f.DiGui(10);
System.out.println(result);//10497
}
public int DiGui(int i) {
if(i == 0) {
return 1;
}else if(i == 1){
return 4;
}else {
return 2*DiGui(i-1) + DiGui(i-2);
}
}
}
（4）
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
MainFunction f = new MainFunction();
int n = 10;
int result = f.DiGui(n);
for(int i = 1;i <= n;i++) {
System.out.println(f.DiGui(i));
}
}
public int DiGui(int i) {
if(i == 1 || i ==2) {
return 1;
}else {
return DiGui(i-1) + DiGui(i-2);
}
}
}
封装和隐藏
程序设计追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅对外暴露少量的方法用于使用
封装性的体现：我们将列的属性私有化（private），同时提供公共的（public）方法获取（getXXX）和设置（setXXX）
不对外暴露的私有方法
单例模式…
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
Amimal a = new Amimal();
a.name = "大象";
a.age = 2;
//a.legNum = 4; //报错：The field Animal.legNum is not visible
a.setLegNum(90);
a.show();
}
}
class Amimal{
String name;
int age;
private int legNum;//腿的个数
public void setLegNum(int l) {
//需要在赋值加入限制条件，只能在方法中进行
if(l >= 0 && l % 2 ==0) {
this.legNum = l;
}else {
legNum = 0;
}
}
public int getLegNum() {
return legNum;
}
public void show() {
System.out.println("age:" + age + ",name:" + name + ",legNum:" + legNum);
}
}
权限修饰符
封装性的体现，需要权限修饰符来配合
四种，大到小：public，protect，缺省，private
构造器
作用：创建对象
package com.atuguigu.java1;
public class Person {
private int age;
String name;
//构造器
public Person() {
System.out.println("Person().....");
}
public int getAge() {
return age;
}
public void setAge(int a) {
if(age < 0 || age > 130) {
System.out.println("can't");
return;
}else {
this.age = a;
}
}
}
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.getAge());
person.setAge(23);
System.out.println(person.getAge());
}
}
结果：
