多维数组
1. 二维数组: 保存了多个数据类型相同的一维数组的数组
一维数组: 数据类型[] 数组名 = 初值;
二维数组: 数据类型[][] 数组名 = 初值;
// 第一种声明二维数组:
int[][] array1 = new int[2][3];
// 声明了有2个 一维数组的二维数组
// 并且每个一维数组 有三个元素.
System.out.println(array1.length);
// 二维数组的长度 打印的是有几个一维数组(2个)
// 第二种声明二维数组:直接把元素声明出来
// {1,2,3} {4,5,6}
// 2行3列的二维数组
int[][] array2 = new int[][] {
{1,2,3},
{4,5,6},
};// 第三种声明 (简便写法)
int[][] array3 = {
{1,2,3},
{4,5,6},
};
// array3取出的是二维数组中的第0个元素(是个一维数组)
System.out.println(array3[0].length);
// 获取元素
System.out.println(array3[0][1]);
// 遍历二维数组
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
System.out.print(array1[i][j] + " ");
}
System.out.println();
}2. 三维数组:保存了多组相同数据类型的二维数组
数据类型[][][] 数组名 = 初值;
int[][][] arr = new int[1][2][3];
(1.二维数组的个数)(2.一维数组的个数)(3.一维数组的元素个数)
//声明有元素的三维数组 223
int[][][] array3 = new int[][][]{
{
{1,2,3};
{4,5,6};
};
{
{7,8,9};
{10,11,12};
};
}
遍历三维数组
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
for (int k = 0; k < array3[i][j].length; k++) {
array3[i][j][k];
}
}
}面向对象之类与对象
1. 面向过程与面向对象的区别
1️⃣面向过程: 强调的是过程 例如: 我来干什么 其中 我是过程执行者
举例: 我要购买电脑(面向过程 强调的是 购买电脑的过程,我是执行者)
1. 挑选CPU
2. 挑选显卡
3. 挑选主板
4. 挑选内存
5. 挑选硬盘
2️⃣面向对象: 强调的是对象 对象来干什么 其中 我由执行者变成指挥者
举例: 我找一个懂电脑的,他帮我挑选
2. 面向对象的好处
1️⃣更贴近人的思维(懒人思维)
2️⃣将复杂的问题简单化
3️⃣从事物的执行者变成事物的指挥者
3. 类与对象
java中最基本的单位 就是类
类: 对抽象事物的描述(模板)
对象: 对抽象事物的 具体描述(利用类创造出来的具体事物)
举例:
学生的信息(模板) ------>类
学生姓名
学生年龄
学生联系方式
小明的信息(具体事物)---->对象
小明
12
手机号xxxxxx
4. 如何描述类和对象
属性(又名:成员变量 实例变量) 用名词叙述 存在位置:类中成员方法外
行为(又名:成员方法 方法) 用动词叙述
//举例: 使用关键词 class
学生类
属性: 姓名 年龄 性别
行为: 吃饭 睡觉 打游戏
----------
特殊:
// 注意:一个.java文件中 可以创建多个不同的类 (但是会生成多个.class文件)
// 但是使用public修饰的类 一个文件中只能有一个
// 并且使用public修饰的类 必须和.java文件名 保持一致
---------
class Student(){
//成员变量(属性):在student类中,在成员方法外面
String name;
int age;
String gender;
//成员方法(行为):先不写static,其他的和函数声明一样
public void eat(){
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void playGame(String gameName) {
System.out.println("玩 " + gameName);
}
}
//举例: 根据学生类,创建一个学生对象
public class Demo{
public static void main(String[] args){
// 类名 + 对象名 = 初值;
// new 会在堆内存中开辟一块空间
// 保存的是 成员变量(属性)
// 成员方法和函数一样,会进栈执行
// 等号前面叫做 对象的引用(保存对象地址)
Student stu1 = new Student();
// 为对象的成员变量赋值
// 对象名.属性名 = 值;
stu1.name = "wangjun123";
stu1.age = 23;
stu1.gender = "男";
// 取值
System.out.println(stu1.name);
System.out.println(stu1.age);
System.out.println(stu1.gender);
// 调用成员方法
// 对象名.方法名(参数);
stu1.eat();
stu1.sleep();
stu1.playGame("英雄联盟");
}
}
// 两个引用 引用同一内存地址
Student s2 = s1;// 将s1的堆内存地址 赋予 s2
s2.name = "wangjun";//更改了堆内存的 成员变量
System.out.println(s1.name);//打印两个对象,对象的成员变量都更改了
5. 成员变量 与 局部变量的区别
1.生命周期(出生到死亡):
成员变量: 随着对象的创建而创建,随着对象的销毁而销毁
局部变量: 随着方法的执行而创建,随着方法的结束而销毁
2.初值:
成员变量: 如果没有初值,系统会给默认值
局部变量: 如果没有初值,不能使用 并会报错
3.作用域:
成员变量: 在整个类中有效
局部变量: 在方法中有效
4.书写位置:
成员变量: 类中方法外
局部变量: 方法上(形参)或方法中
5.在内存中的表现:
成员变量: 保存在堆内存中
局部变量: 运行在栈内存中
**就近原则(当成员变量与局部变量相同的时候,赋值变量 是改变最近的那个)
详见后面 面向对象特征之封装**
车类Car
成员变量:车名 排气量 颜色
成员方法:
停车
介绍自己的方法
class Car{
// 姓名
String name = "Veneno";
// 排气量
String displacement = "双涡轮增压";
// 颜色
String color = "black";
// 局部变量的位置: 方法上(相当于函数形参) 或者 方法中
// 开车
public void run() {
// !!!!!就近原则(当成员变量与局部变量相同的时候)
String name = "wangjun123"; //成员变量可以不给初值就使用,局部变量不给初值不能使用
System.out.println(name);
System.out.println("开车");
}
//介绍自己的方法
public void sayHi() {
// 成员变量 作用域: 整个类都能访问
System.out.println("车名:" + name);
System.out.println("排量:" + displacement);
System.out.println("颜色:" + color);
}
}
public class Demo03 {
public static void main(String[] args) {
Car c1 = new Car();
c1.sayHi();
c1.run();
}
}项目中能不能有两个同样的类?
可以的 (但是最好两个类不要同包)
注意:开发中最好不要使用同名的类(避免麻烦)
// 创建一个person对象
// 默认创建的是 与本类 同包的类的对象
Person person = new Person();
person.sayHi();
// 如何创建test1包下的person对象
// 使用类的 全类名(包名加类名)来创建
com.wj.test1.Person p1 = new com.wj.test1.Person();
p1.sayHi();6.匿名对象 (对象作为方法的参数,使用较少)
1.什么是匿名对象?
匿名对象(没有名字的对象)
1️⃣省略代码(省略了类名 对象名 =)
2️⃣一般可以当做 传递的参数来使用
public class Demo {
// 修改对象的name
// Person p = p1;
// 引用数组类型 参数传递的是地址
public static void fun(Person p) {
p.name = "wangjun";
p.sayHi();
}
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "wangjun123";
p1.age = 23;
p1.sayHi();
// 调用方法
fun(p1);
p1.sayHi();
// 创建匿名对象
// new 开辟了三个不同的堆内存空间 之间没有联系
new Person().name = "Faker";
new Person().age = 22;
new Person().sayHi();
// 可以当参数来用 减少代码
fun(new Person());
// 测试方法时使用
}
} 面向对象特征之封装
1.面向对象的三大特征: 封装 继承 多态
2.封装:
1️⃣方法本身就是一种分装
2️⃣将代码的实现或者属性隐藏 不让外界直接访问
对外提供访问的方法(间接访问) 关键词: private(私有)
被private修饰的成员变量,只能被本类进行访问
(要想在其他类使用,只能在本类声明方法,在其他类声明对象时,调用这个方法并提供参数,来进行修改
// 举例 类的属性封装
//要封装的类
class Student{
// 属性(成员变量)私有化,不让外界直接访问
private String name;
private String age;
// 私有化之后,需要提供对外的访问方法
// 每一个成员变量
// 需要提供一对访问方法,赋值(set 方法)和取值(get 方法)
/*(javaBean(实体类)规范
1.成员变量私有化
2.提供set/get方法 )*/
// 命名规范:set + 成员变量名(参数[要改变后的名字]) 使用的是小驼峰
public void setName(String name){
this.name = name;
// 就近原则 (两个name都是形参)
//!!! 使用关键字 this
// this 表示本类的对象
// this.name 表示本类的name属性
// this 表示谁调用了这个方法,谁就是this
}
public String getName() {
return name;
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
}// 访问封装的类
public class Demo {
public static void main(String[] args) {
Phone p1 = new Phone();
// 封装后直接访问,提示错误
// p1.name = "xiaomi";
// p1.age = 12;
// 间接访问,调用了Student类的访问方法.
p1.setName("张三");
System.out.println(p1.getName());
}
}