匿名对象
理解：创建对象时，没有显式地赋予一个变量名，即匿名对象
特征：匿名对象只能调用一次
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 Person(String n) {
this.name = n;
}
public Person(String n,int age) {
this.name = n;
this.age = age;
}
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());
Person p2 = new Person("张三");//初始化对象的属性：名字为张三
System.out.println(p2.name);
Person p3 = new Person("李四",4);
System.out.println(p3.getAge());
}
}
结果：
任何的类都有构造器
说明：
如果没有显式的定义的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：全新啊修饰符 类名（形参列表）{}
一个类中定义的多个构造器，彼此构成重载
一旦我们显式的定义了类的构造器后，系统就不再提供默认的空参构造器
一个类中至少有一个构造器
练习
package com.atuguigu.java1;
//三角形的类
public class TriAngle {
private double base;//底边长
private double height;//高
public double getBase() {
return base;
}
public void setBase(double b) {
this.base = b;
}
public double getHeight() {
return this.height;
}
public void setHeight(double h) {
this.height = h;
}
public TriAngle(double base,double height) {
this.base = base;
this.height = height;
}
public double getArea() {
return this.base*this.height/2;
}
}
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
TriAngle triAngle = new TriAngle(4.5, 5);//11.25
System.out.println(triAngle.getArea());
}
}
属性赋值的先后顺序
1、默认初始化
2、显式初始化
3、构造器中初始化
4、通过“对象.方法”或“对象.属性”的方式赋值
javaBean
是一种java语言写成的可重用组件
符合以下表尊：类是公共的，有一个无参的公共构造器，有属性且对应get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其它任何可以用java代码创造的对象进行打包，并且其他的开发者可以用通过内部JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
UML类图
关键字：this
可以用来修饰属性、方法、构造器；
this理解为当前对象；
在类的方法中，可以用“this.属性”或“this.方法”调用，通常可以省略，但方法形参和类的属性同名，必须用“this.变量”（在构造器中，传入的形参同理）；
this调用构造器：
在类的构造器当中，可以显式的使用“this(形参列表)”方式，调用本类中指定的其他构造器，构造器不能通过this(形参列表)来调用自己；
如果一个类中有n个构造器，则最多有n-1构造器使用this(形参列表)；
规定：“this（形参列表）”必须声明在当前构造器首行；
构造器内部，最多只能声明一个this(形参列表)
package com.atuguigu.java1;
//三角形的类
public class People {
private int id;
private String name;
public void eat() {
System.out.println("eating");
}
public People() {
this.eat();
}
public People(int id) {
this();//相当于调用了构造器People(){}
this.id = id;
}
public People(int id,String name) {
this(id);//相当于调用了构造器People(id){}
this.name = name;
}
}
package com.atuguigu.java1;
public class MainFunction {
public static void main(String[] args) {
People p1 = new People(23,"chen");//output:eating
}
}
*例子：
*
package com.study.java1;
import com.sun.org.apache.bcel.internal.generic.I2F;
public class Boy {
private String name;
private int age;
public Boy() {
System.out.println("我被创建了！");
}
public Boy(String name) {
this();
this.name = name;
}
public Boy(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void marry(Girl girl) {
System.out.printf("marry with %s",girl.getName());
}
public void shout() {
if(this.age>22) {
System.out.println("可以去登记了");
}else {
System.out.println("可以去工地了");
}
}
}
package com.study.java1;
public class Girl {
private String name;
private int age;
public Girl(){
System.out.println("我被创建出来了！");
}
public Girl(String name) {
this();
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void marry(Boy boy) {
System.out.printf("Marry with %s",boy.getName());
}
public int compare(Girl girl) {
if(this.age > girl.age) {
return 1;
}else if(this.age < girl.age) {
return -1;
}else {
return 0;
}
}
}
package com.study.java1;
public class mainFuction {
public static void main(String[] args) {
Boy boy = new Boy("张三");
Girl girl = new Girl("陈");
Girl girl2 = new Girl("白");
girl.marry(boy);
}
}
结果：
package
方便管理，提出包概念，命名规则“xxxxxyyyy”，见名知义
每“."一下，代表一层目录
同一个包下不能命名同名接口和类，不同包下可以同名接口或类
import
导入，在源文件中，显式的使用import结构导入指定包下的类、接口，声明在包和类之间。
使用“xxx.*"结构，表示可以导入xxx包下的所有结构。
如果使用的类或接口属于java.lang或本包下定义的，可以省略import
如果在源文件中使用了不同包下的同名的类，则必须至少有一个用全命名的形式。
import static:导入指定类或接口中的静态结构
写在后面
趁着b站现在崩掉，导致我无法观看后面的视频，来说几句。
本人于7月5日入职，做机械的岗位，然后当晚决定自学java，尝试转行（其实意愿很大），到如今有一周多了，每天六点起床，学一个小时多，然后就去工厂上班了，晚上下班，近七点回到宿舍继续学，十二点上床，避免影响第二天的工作（毕竟拿了钱，工作还是要认真）。在毕业之前，我都不敢想象我会有今天这种生活状态，不过心态也在第一天就转变过来了，口号之类的话就不说了，希望能保持健康的身体来完成接下来的学习，共勉。
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
