零、复习昨日
一、一日一题（数组，OOP）
package com.qf0208;
import java.util.Arrays;
public class Task2 {
public static void main(String[] args) {
int[] arr1 = {1,2,5,8,9};
int[] arr2 = {1,3,0};
plus(arr1, arr2);
}
/* 写一个方法 用于合并两个int类型的数组 合并法则如下
* {1,2,5,8,9}{1,3,0}---->{0,1,2,3,5,8,9}
*/
public static void plus(int[] arr1,int[] arr2) {
// 合并
int[] arr3 = new int[arr1.length + arr2.length];
System.arraycopy(arr1, 0, arr3, 0, arr1.length);
System.arraycopy(arr2, 0, arr3, arr1.length, arr2.length);
System.out.println(Arrays.toString(arr3));
// 去重
// 创建新数组,存放不重复的元素
int[] arr4 = new int[arr3.length];
Arrays.sort(arr3);
arr4[0] = arr3[0];
int index = 1;
// 取源数组
for (int i = 1; i < arr3.length; i++) {
boolean flag = false;// 不重复
// 去重后数组的元素
for (int j = 0; j < arr4.length; j++) {
if (arr3[i] == arr4[j]) {
flag = true;
}
}
if (!flag) {
arr4[index] = arr3[i];
index++;
}
}
System.out.println(Arrays.toString(arr4));
int[] arr5 = new int[index];
System.arraycopy(arr4, 0, arr5, 0, index);
System.out.println(Arrays.toString(arr5));
}
}同一个Java文件中只能有一个公共的类，且公共的类的名字要和外面的文件名一样。
二、面向对象练习（方法参数返回值）
联系方法参数，进行返回值
package com.qf0213;
/**
* @escription:
* @author:灰总
* @time:
*/
public class Phone {
String brand;
double price;
public boolean call(String num){
System.out.println(brand + "打电话");
return true;
}
}
class TestPhone{
public static void main(String[] args) {
Phone phone = new Phone();
phone.brand = "MI";
phone.price = 1888.0;
boolean isok = phone.call("110");
System.out.println("打电话是否成功？" + isok);
}
}三、局部变量&成员变量
成员变量属于对象。
局部变量 | 成员变量 | |
位置 | 方法参数列表和方法体内 | 类中方法外 |
作用域 | 只能在方法内部使用 | 类中所有方法 |
初始值 | 使用前必须主动赋值 | 成员变量会随着创建对象时被赋默认值 |
内存位置 | 在栈的栈帧中 | 在内存的堆中 |
生命周期 | 会随着方法进栈而出现，方法执行完出栈而消失 | 在对象创建时出现并赋初始值，失去引用后会被gc(垃圾回收机制处理)回收 |
public class Phone {
/**
* 成员属性就是成员变量
* 1 类中方法外
* 2 类中所有方法都可以使用
* 3 成员变量会随着创建对象时被赋默认值(即可以不用主动考虑初始值的事)
* 4 成员变量在内存的堆中
* 5 在对象创建时出现并初始化,失去引用后,会把垃圾回收机制处理(GC)
*/
String brand;
double price;
/**
* 局部变量
* 1 方法参数列表内和方法体内
* 2 只能在方法内部使用
* 3 局部变量使用前必须主动赋值
* 4 局部变量是在栈的栈帧中
* 5 随着方法进栈而出现,方法执行完出栈而消失
*/
public boolean call(String num) {
int a = 1;
System.out.println(a );
System.out.println(brand + "打电话" + num);
System.out.println("这个手机价格:" + price);
return true;
}
}
四、this关键字
this就是代表当前对象
当前对象就是指谁调用这个方法，this就代表调用这个方法的对象。因为this代表的是对象，所以它就可以调用对象的属性和方法
this.属性；
this.方法()；
package com.qf.oop;
/**
* --- 天道酬勤 ---
*
* @author QiuShiju
* @desc
*/
public class Car {
String brand;
double price;
public void run() {
int a = 1;
String brand = "五菱";
System.out.println("this:"+this );// 输出的是car的地址,代表car对象
/**
* 当成员变量和局部变量重名时
* 使用时,默认使用方法自己的局部变量(就近原则)
* 如果必须使用成员变量,就使用this来调用
* 因为this代表对象,所以可以调用对象属性
*/
System.out.println(this.brand + "车跑动,跑了"+a+"公里" );
// this调用方法
this.didi();
}
public void didi() {
System.out.println("车鸣笛" );
}
}
class TestCar {
public static void main(String[] args) {
Car car = new Car( );
System.out.println("car:" + car );
car.brand = "BYD";
car.price = 150000;
car.run();
}
}
使用this的场景总结：
当成员变量和局部变量重名时，用this属性来代表成员变量
五、构造方法【重要】
构造方法又叫构造器（constructor），是用来创建对象的。
类名 对象名 = new 类名();
其实这个语法应该这么叫：
类名 对象名 = new 构造方法();
特点：
每个类都默认有一个无参构造
没有返回值，也不能写void
方法名必须是类名，类名必须大写
只能通过new来调用
特殊的：类中没有一个显示构造方法，那么就会提供一个隐式无参构造，一旦显示写出任何一个构造方法，隐式的不再提供。
具体作用（构造方法一旦执行）
在堆中开辟空间，分配地址空间
属性和方法被初始化
然后执行构造方法内部的代码
对象创建成功将地址值赋给变量（对象名）
有参构造
在创建对象时，调用有参构造方法，方法内部有属性赋值的过程，所以有参构造创建出的对象的属性是指定值。
public class Student {
String name;
int age;
/**
* 显示的写出无参构造
* 构造方法语法特点
* 1. 没有返回值,也不能写void
* 2. 方法名必须是类名
*/
public Student(){
System.out.println("无参构造" );
}
/**
* 有参构造
*/
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void coding(){
System.out.println("敲代码" );
}
}
class TestStudent{
public static void main(String[] args) {
// ???? 能不能创建出的对象,内部的属性直接有值
// 能!!! 有参构造
Student s2 = new Student("奥利安娜", 20);
System.out.println(s2.age );
System.out.println(s2.name);
}
}
总结有参构造和无参构造的区别
相同点：都能创建出对象
不同点：无参构造创建出的对象属性是默认值；有参构造创建出的对象属性是指定值
即两者都是创建对象，只是不同的效果，看情况选择使用
六、重载
重载：overload；方法的重载
方法是在同一个类中
方法名相同，参数列表不同
参数列表不同：个数、类型、顺序不同都叫不同好处：
方便调用，根据传入的参数的个数、顺序、类型决定执行那个方法，不同的设计取不同的方法名。
七、封装
类的封装：将代码封装在一个类中，隐藏一些代码实现的逻辑，对外提供一个公共的访问方式
类的封装实现步骤：
属性私有
提供对应的set、get方法set、get方法，很固定
一定是set+首字母大写 setXxx getXxx
set方法有参数无返回值
get方法无参数有返回值
package com.qf0213;
/**
* @escription:
* @author:灰总
* @data:
*/
public class People {
// 私有化，这个属性就只能在当前类中使用
private int age;
private String name;
// 提供set方法供赋值
public void setAge(int age){
if (age <= 120 && age >= 0){
this.age = age;
} else {
System.out.println("年龄有误！");
}
}
// 提供get方法取值
public int getAge(){
return age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class TestPeople{
public static void main(String[] args) {
People people = new People();
// people.name = "liuzhuo";
// people.age = 23;
people.setAge(23);
int age = people.getAge();
people.setName("liuzhuo");
String name = people.getName();
// System.out.print(people.name + " ");
System.out.print(name);
System.out.println(age);
}
}八、总结
局部变量成员变量：能分清，初始值不同
this：代表当前对象，场景用来区分成员变量和局部变量
构造方法：用来创建对象，油藏和无参构造的区别
重载：是代码的一种设计方式，可以让方法调用更方便
类的封装：先属性私有后提供一对儿set、get方法
