小黑子—Java从入门到入土过程：第五章
Java零基础入门5.0
- Java系列第五章
-
- 1. 方法
-
- 1.1 方法的简单定义
- 1.2 带参方法
- 1.3 带返回值的方法和调用
- 1.4 方法小结
-
- return 关键字
- 换行
- 1.5 方法的重载
- 1.6 方法的基本内存原理
- 1.7 方法的值传递
- 2. 基本数据类型和引用数据类型
- 3. 综合练习
-
- 3.1 案例一：卖飞机票
-
- 快捷键自动抽取方法 ctrl +alt + m
- 3.2 案例二：找质数
- 3.3 案例三：开发验证码
- 3.4 案例四：数组元素的复制
- 3.5 案例五：评委打分
- 3.6 案例六：数字加密
- 3.7 案例七：数字解密
- 3.8 案例八：抢红包
- 3.9 案例九：双色球系统
- 4. 二维数组
-
- 4.1 二维数组的静态初始化
- 4.2 二维数组的动态初始化
- 4.3 二维数组的内存图
- 5. 面向对象
-
- 5.1 类和对象
-
- 类
- 类的设计
- 5.2 封装
-
- private 权限修饰
- 5.4 this 关键字
- 5.5 构造方法
- 5.6 标准的javabean
-
- 快捷键一键生成构造
- 插件PTG 1秒生成标准Javabean
- 5.6 三种情况的对象内存图
- 5.7 数据类型
- 5.8 this的内存原理
- 5.9 成员和局部
- 5.10 java中的psvm
Java系列第五章
1. 方法
1.1 方法的简单定义
1.2 带参方法
1.3 带返回值的方法和调用
案例：
public static void main(String[] args) {
int sum1 = getSum(10,20,30);
int sum2 = getSum(40,50,60);
int sum = sum1+sum2;
System.out.println(sum);
}
public static int getSum(int num1, int num2, int num3) {
int result = num1 + num2 + num3;
return result;// 返回给方法的调用处
}
1.4 方法小结
1.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
int[] arr ={11,222,33,44,55};
printArr(arr);
}
public static void printArr(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+",");
}
}
System.out.print("]");
}
}
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
int[] arr ={1,5,7,3,8,10};
int max = getMax(arr);
System.out.println(max);
}
public static int getMax(int[] arr){
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if(arr[i]>max){
max = arr[i];
}
}
return max;
}
}
3.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
int[] arr ={1,5,8,12,56,89,34,67};
boolean flag = contains(arr,89);
System.out.println(flag);
}
//1.我要干嘛? 判断数字在数组中是否存在
//2.我干这件事情,需要什么才能完成?_数组数字
// 3.调用处是否需要继续使用结果?返回true false
public static boolean contains(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==number){
return true;
}
}
return false;
}
}
4.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int [] copyArr = copyOfRange(arr,3,7);
for (int i = 0; i < copyArr.length; i++) {
System.out.print(copyArr[i]+" ");
}
}
//将数组arr中从索引from(包含from）开始,到索引to结束（不包含to）的元素复制到新数组中
public static int[] copyOfRange(int[] arr, int from,int to) {//3~7
// int[] 定义返回数组的函数
int[] newArr =new int[to-from];
//2.把原始数组arr中的from到to上对应的元素，直接拷贝到newArr中
//伪造索引的思想
int index = 0;
for (int i = from; i < to; i++) {
// 格式：数组名[索引]=数组值
newArr[index] = arr[i];
index++;
}
return newArr;
}
}
return 关键字
- 方法没有返回值:可以省略不写。如果书写，表示结束方法
- 方法有返回值:必须要写。表示结束方法和返回结果
return break关键字的区别
return:
-
其实跟循环没有什么关系，跟方法有关的，表示1结束方法 2返回结果
-
如果方法执行到了return，那么整个方法全部结束，里面的循环也会随之结束了。
break关键字
- 其实跟方法没有什么关系，结束循环或者switch的。
换行
System.out.println("abc");//带ln 先打印abc，再进行换行
System.out.print("abc");// 不带ln 只打印abc，不换行
System.out.println();// 只换行
1.5 方法的重载
java 中提供了一个 方法命名的时候可以重名，但是方法的形参不能一样
练习：
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
compare(10, 20);
compare((byte) 10,(byte) 20);
short s1 =30;
short s2 =50;
compare(s1,s2);
}
//会把相同功能的方法名起成一样的名字
//好处1:定义方法的时候可以不用那么多的单词了
// 好处2:调用方法的时候也不需要那么麻烦了。
public static void compare(byte b1, byte b2) {
System.out.println("byte");
System.out.println(b1 == b2);
}
public static void compare(short s1, short s2) {
System.out.println("short");
System.out.println(s1 == s2);
}
public static void compare(int i1, int i2) {
System.out.println("int");
System.out.println(i1 == i2);
}
public static void compare(long n1, long n2) {
System.out.println("long");
System.out.println(n1 == n2);
}
}
1.6 方法的基本内存原理
方法被调用之后就会进栈执行
当方法执行完毕之后，方法便会出栈，当方法出栈之后内容消失，程序结束。
1.7 方法的值传递
传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
2.传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值
小结：
2. 基本数据类型和引用数据类型
只要是new出来的，就是引用数据类型
3. 综合练习
3.1 案例一：卖飞机票
package com.itheima.demo1;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String args[]) {
//分析：
//1.键盘录入：机票原价、月份、头等舱或经济舱
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票的原价：");
int ticket = sc.nextInt();
System.out.println("请输入当前的月份：");
int month = sc.nextInt();
System.out.println("请输入当前购买的舱位 0 头等舱或 1 经济舱");
int seat = sc.nextInt();
//2.先判断月份是旺季还是淡季
if (month >= 5 && month <= 10) {
// 旺季
//3.继续判断当前机票是经济舱还是头等舱
if (seat == 0) {
// 4.根据实际情况计算出对应的价格
// 头等舱
ticket = (int) (ticket * 0.7);
} else if (seat == 1) {
ticket = (int) (ticket * 0.85);
} else {
System.out.println("没有这个舱位");
}
} else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
// 淡季
if (seat == 0) {
// 头等舱
ticket = (int) (ticket * 0.7);
} else if (seat == 1) {
ticket = (int) (ticket * 0.85);
} else {
System.out.println("没有这个舱位");
}
} else {
System.out.println("键盘录入的月份不合法：");
}
System.out.println(ticket);
}
}
代码优化：
package com.itheima.demo1;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String args[]) {
//分析：
//1.键盘录入：机票原价、月份、头等舱或经济舱
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票的原价：");
int ticket = sc.nextInt();
System.out.println("请输入当前的月份：");
int month = sc.nextInt();
System.out.println("请输入当前购买的舱位 0 头等舱或 1 经济舱");
int seat = sc.nextInt();
//2.先判断月份是旺季还是淡季
if (month >= 5 && month <= 10) {
// 旺季
//3.继续判断当前机票是经济舱还是头等舱
ticket = getPrice(ticket, seat, 0.9, 0.85);
} else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
// 淡季
ticket = getPrice(ticket, seat, 0.7, 0.65);
} else {
System.out.println("键盘录入的月份不合法：");
}
System.out.println(ticket);
}
//1.我要干嘛﹖根据舱位和折扣来计算最终的票价
//2.我干这件事，需要什么才能完成?原价舱位头等舱的折扣经济舱的折扣
// 3.方法的调用处是否需要继续使用这个结果需要
public static int getPrice(int ticket, int seat, double v0, double v1) {
// 淡季
if (seat == 0) {
// 头等舱
ticket = (int) (ticket * 0.7);
} else if (seat == 1) {
ticket = (int) (ticket * 0.85);
} else {
System.out.println("没有这个舱位");
}
return ticket;
}
}
快捷键自动抽取方法 ctrl +alt + m
3.2 案例二：找质数
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String args[]) {
int count = 0;
for (int i = 101; i < 200; i++) {
boolean flag = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag) {
System.out.println("当前数字" + i + "是质数");
count++;
}
}
System.out.println("一共有" + count + "个质数");
}
}
3.3 案例三：开发验证码
package com.itheima.demo1;
import java.util.Random;
public class ArithmeticoperatorDemo1 {
public static void main(String args[]) {
//方法:
//在以后如果我们要在一堆没有什么规律的数据中随机抽取//可以先把这些数据放到数组当中
//再随机抽取一个索引
//1.大写字母和小写字母都放在数组当中
char[] chs = new char[52];
for (int i = 0; i < chs.length; i++) {
//利用ASCII码表
if (i <= 25) {
chs[i] = (char) (97 + i);
} else {
chs[i] = (char) (65 + i - 26);
}
}
// 定义一个字符串类型的变量，用来记录最终的结果
String result = "";
//2. 随机抽取4次
// 随机抽取数组的索引
Random r = new Random();
for (int i = 0; i < 4; i++) {
int randomIndex = r.nextInt(chs.length);
//利用随机索引查询，获取随机的元素
result += chs[randomIndex];
}
//3. 随机抽取一个数字0~9
int number = r.nextInt(10);
// 最终生成结果
result += number;
System.out.println(result);
}
}
3.4 案例四：数组元素的复制
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String args[]) {
// 分析：
//1.定义一个老数组并存储一些元素
int[] arr={1,2,3,4,5};
//2.定义一个新数组的长度跟老数组一致
int[] newArr = new int[arr.length];
//3.遍历老数组，得到老数组中的每一个元素，依次存入到新数组当中
for (int i = 0; i < arr.length; i++) {
//i表示老数组中的索引。新数组中的每一个索引
// arr[i]表示老数组中的元素
newArr[i]=arr[i];
}
//4.新数组中已经存满了
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
}
3.5 案例五：评委打分
package com.itheima.demo1;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String args[]) {
//分析:
//1.定义一个数组，用来存储6名评委的打分(0~108)
int[] scoreArr = getScores();
for (int i = 0; i < scoreArr.length; i++) {
System.out.println(scoreArr[i]);
}
//2.求出数组中的最大值
int max = getMax(scoreArr);
//3.求出数组中的最小值
int min = getMin(scoreArr);
//4.求出数组中6个分数的总和
int sum = getSum(scoreArr);
// 5.(总和–最大值-最小值)/ 4
int avg = (sum-max-min)/(scoreArr.length-2);
System.out.println("选手的最终得分为："+avg);
}
public static int getSum(int[] scoreArr) {
int sum = 0;
for (int i = 0; i < scoreArr.length; i++) {
sum += scoreArr[i];
}
return sum;
}
//求出数组的最大值
public static int getMax(int[] scroeArr) {
int max = scroeArr[0];
for (int i = 0; i < scroeArr.length; i++) {
if (scroeArr[i] > max) {
max = scroeArr[i];
}
}
return max;
}
//求出数组的最小值
public static int getMin(int[] scroeArr) {
int min = scroeArr[0];
for (int i = 0; i < scroeArr.length; i++) {
if (scroeArr[i] < min) {
min = scroeArr[i];
}
}
return min;
}
//1.我要干嘛?定义一个数组，用来存储6名评委的打分（o~100>
//2.我需要什么?都不需要
//3.干完了这件事情，是否需要返回?必须返可
public static int[] getScores() {
int[] scores = new int[6];
// 键盘录入，输入分数：0~100
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入"+i+"评委的打分：");
int score = sc.nextInt();
if (score >= 0 && score <= 100) {
scores[i] = score;
} else {
System.out.println("成绩超出了范围，继续录入，当前的i为：" + i);
}
}
return scores;
}
}
3.6 案例六：数字加密
1.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//分析:
//1.把整数里面的每一位放到数组当中
int[] arr = {1, 9, 8, 3};
//2.加密
// 每位数上加5
for (int i = 0; i < arr.length; i++) {
arr[i] += 5;
}
// 再对10求余
for (int i = 0; i < arr.length; i++) {
arr[i] %= 10;
}
// 将所有数字反转
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 8 3 4 6 -->8346
//3.把数组里面的每一个数字进行拼接，变成加密之后的结果
int number = 0;
for (int i = 0; i < arr.length; i++) {
number = number * 10 + arr[i];
}
System.out.println(number);
}
}
2.反向推导
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
// 1. 计算出数组的长度
int number = 12345;
// 定义一个变量临时记录number的值，就是为了第三步的时候再次使用
int temp = number;
//定义一个变量进行统计
int count = 0;
while (number != 0) {
//每次循环都去掉右边的一个数字
number = number / 10;
//去掉一位计数器就自增一次
count++;
}
//2.定义数组
//动态初始化
int[] arr = new int[count];
//3.把整数上的每一位都添加到数组当中
int index = arr.length-1;
while (temp != 0) {// 12345
// 获取temp里面的每一位数组
int ge = temp % 10;
//再次去掉右边的那位数字
temp = temp / 10;
//把当前获取到的个位添加到数组当中
arr[index] = ge;
index--; // 当int index = 0;赋值index时，index++后54321就从后面开始了
}
// 验证结果
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
3.7 案例七：数字解密
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
int[] arr={8,3,4,6};
// 反转
for (int i =0,j=arr.length-1;i<j;i++,j--){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//3.由于加密是通过对10取余的方式进行获取的
// 所以在解密的时候就需要判断，0~4之间+10 5~9数字不变
for (int i = 0; i < arr.length; i++) {
if (arr[i]>=0&&arr[i]<=4) {
arr[i]=arr[i]+10;
}
}
//4.每一位减5
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]-5;
}
//5.获取数组里面的每一位数字拼接成最终的结果
int number =0;
for (int i = 0; i < arr.length; i++) {
number=number*10+arr[i];
}
System.out.println(number);
}
}
3.8 案例八：抢红包
package com.itheima.demo1;
import java.util.Random;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//1.把奖池里面的所有奖项打乱循序
int[] arr ={2,588,888,1000,10000};
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
int randomIndex = r.nextInt(arr.length);
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//2.遍历奖池，从0索引开始获取每一个奖项
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
3.9 案例九：双色球系统
package com.itheima.demo1;
import java.util.Random;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr = createNumber();//123456 7
System.out.println("====================");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println("====================");
//2.用户输入彩票号码（红球+篮球）
int[] userInputArr = userInputNumber();
//3.判断用户的中奖情况
//红球 蓝球
int redCount = 0;
int blueCount = 0;
//判断红球
for (int i = 0; i < userInputArr.length; i++) {
int redNumber = userInputArr[i];
for (int j = 0; j < arr.length - 1; j++) {
if (redNumber == arr[j]) {
redCount++;
//如果找到了，那么后面的数字就没有必要继续比较了
// 跳出内循环，继续判断下一个红球号码是否中奖
break;
}
}
}
// 判断蓝球
int blueNumber = userInputArr[userInputArr.length - 1];
if (blueNumber == arr[arr.length - 1]) {
blueCount++;
}
// 根据红球的个数以及蓝球的个数来判断中奖的情况
if (redCount == 6 && blueCount == 1) {
System.out.println("恭喜你，中奖1000万");
} else if (redCount == 6 && blueCount == 0) {
System.out.println("恭喜你，中奖500万");
} else if (redCount == 5 && blueCount == 1) {
System.out.println("恭喜你，中奖3000");
} else if (redCount == 5 && blueCount == 0 || (redCount == 4 && blueCount == 1)) {
System.out.println("恭喜你，中奖200");
} else if (redCount == 4 && blueCount == 0 || (redCount == 3 && blueCount == 1)) {
System.out.println("恭喜你，中奖10");
}else if(redCount == 4 && blueCount == 0 || (redCount == 3 && blueCount == 1) || (redCount == 0 && blueCount == 1)){
System.out.println("恭喜你，中奖5");
}else{
System.out.println("谢谢参与，谢谢惠顾");
}
}
public static int[] userInputNumber() {
//1.创建数组用于添加用户购买的彩票号码
// 6个红球1个蓝球数组长度:7
int[] arr = new int[7];
// 利用键盘录入让用户输入
Scanner sc = new Scanner(System.in);
//让用户输入红球号码
for (int i = 0; i < 6;) {
System.out.println("请输入第" + (i + 1) + "个红球号码");
int redNumber = sc.nextInt();
//redNumber 在1~33 唯一不重复
if (redNumber >= 1 && redNumber <= 33) {
boolean flag = contains(arr, redNumber);
if (!flag) {
// 不存在
arr[i] = redNumber;
i++;
} else {
//存在
System.out.println("当前红球号码已经存在，请重新输入：");
}
} else {
System.out.println("当前红球号码超出范围");
}
}
//让用户输入蓝球号码
System.out.println("请输入蓝球号码：");
//1~16
while (true) {
int blueNumber = sc.nextInt();
if (blueNumber >= 1 && blueNumber <= 16) {
arr[arr.length - 1] = blueNumber;
break;
} else {
System.out.println("当前蓝球号码超出范围");
}
}
return arr;
}
public static int[] createNumber() {
//1.创建数组用于添加中奖的号码
//6个红球 1个蓝球 数组长度：7
int[] arr = new int[7];
//2.随机生成号码并添加到数组当中
// 红球:不能重复的1 2 3 4 5 6
//蓝球:可以跟红球号码重复 5
// 生成红球号码并添加到数组当中
Random r = new Random();
for (int i = 0; i < 6; ) {
// 获取红球号码
int redNumber = r.nextInt(33) + i;
boolean flag = contains(arr, redNumber);
if (!flag) {
arr[i] = redNumber;
i++;
}
}
// 生成蓝球号码并添加到数组当中
int blueNmber = r.nextInt(16) + 1;
arr[arr.length - 1] = blueNmber;
return arr;
}
public static boolean contains(int[] arr, int number) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
return true;
}
}
return false;
}
}
4. 二维数组
4.1 二维数组的静态初始化
//1.二维数组静态初始化格式
//数据类型[][] 数组名=new 数据类型[][]{{元素1，元素2},{元素1，元素2}}
int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6, 7, 8}};
int[][] arr2 = {{1, 2, 3}, {4, 5, 6, 7, 8}};
//以后建议这样定义，把每一个一维数组，单独写成一行
//注意:每一个一维数组其实是二维数组中的元素，所以每一个一维数组之间需要用逗号隔开。最后一个一维数组后面不需婴加逗号
int[][] arr3 = {
{1, 2, 3},
{4, 5, 6, 7, 8}
};
//2.获取元素
//arr[i][j]
//arr:二维数组
//i:二维数组的索引，获取出来的是里面的一维数组
//j:表示一维数组中的索引，获取出来的就是真正的元素
//System.out.println(arr3[0]); 表示获取二维数组中的第一个一维数组
//arr3[0]:二维数组中的第一个一维数组
//arr3[0][0]：获取第一个一维数组中0索引的元素
//System.out.println(arr3[2][0]); 报错ArrayIndexOutOfBoundsException超出数组范围
//3.二维数组遍历
//外循环:遍历二维数组，得到里面的每一个一维数组
for (int i = 0; i < arr3.length; i++) {
//i:表示二维数组中的每一个索引
//arr3[i]:表示二维数组中的每一个元素（一维数组）
//内循环:遍历一维数组，得到里面的每一个元素
for (int j = 0; j < arr3[i].length; j++) {
//j：表示一维数组中的每一个元素
System.out.print(arr3[i][j]+" ");
}
System.out.println();
}
4.2 二维数组的动态初始化
//1.利用动态初始化格式创建二维数组
//3:表示二维数组长度为3，可以装3个一维数组
//5:表示每一个一维数组的长度都是5，可以装5个int类型的元素
int[][] arr = new int[3][5];
// 给二维数组赋值一个元素
arr[0][0]=10;
//遍历二维数组
//外循环：遍历二维数组获取里面的每一个一维数组
//内循环
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
4.3 二维数组的内存图
练习：
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//1.创建二维数组并存储数据
int[][] yearArrArr = {
{22,66,44},
{77,33,88},
{25,45,65},
{11,66,99}
};
//表示全年的营业额
int yearSum = 0;
//2.遍历二维数组，得到每一个一维数组并求和
for (int i = 0; i < yearArrArr.length; i++) {
//i 二维数组中的每一个索引
// yearArrArr[i] 元素（一维数组）
int[] quarteArr = yearArrArr[i];
int sum = getSum(quarteArr);
System.out.println("第"+(i+1)+"个季度的总营业额为："+sum);
yearSum += sum;
}
System.out.println("全年总营业为："+yearSum);
}
//定义一个方法，计算每一个季度的营业额
public static int getSum(int[] arr){
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
}
5. 面向对象
面向对象介绍
- 面向:拿、找
- 对象:能干活的东西
- 面向对象编程:拿东西过来做对应的事情
5.1 类和对象
小结：
类
定义类的补充注意事项
- 用来描述一类事物的类，专业叫做:Javabean类。在Javabean类中，是不写main方法的。
- 在以前，编写main方法的类，叫做测试类。 我们可以在测试类中创建javabean类的对象并进行赋值调用。
练习：
1.在同一个包下创建一个类
GirlFriend类
package com.test2;
public class GirlFriend {
// 属性
String name;
int age;
String gender;
// 行为
public void sleep(){
System.out.println("李在睡觉？");
}
public void eat(){
System.out.println("李在吃饭？");
}
}
2.引入到新的java文件当中
package com.test2;
public class GrilFreindTest {
public static void main(String[] args) {
// 创建对象
GirlFriend gf1 = new GirlFriend();
gf1.name = "麻瓜";
gf1.age=18;
gf1.gender="man";
System.out.println(gf1.name);
System.out.println(gf1.age);
System.out.println(gf1.gender);
gf1.eat();
gf1.sleep();
System.out.println("==============");
// 创建第二个对象
GirlFriend gf2 = new GirlFriend();
gf2.name = "马捞c";
gf2.age=18;
gf2.gender="man";
System.out.println(gf2.name);
System.out.println(gf2.age);
System.out.println(gf2.gender); //按住鼠标滚轮往下拖，可以起到多个光标选取的效果
}
}
小结：
类的设计
5.2 封装
java封装的对象包
private 权限修饰
1.创建
package com.test2;
public class GirlFriend {
// 属性
private String name;
private int age;
private String gender;
//针对于每一个私有化的成员变量，都要提供get和set方法
//set方法:给成员变量赋值
//get方法:对外提供成员变量的值
//作用：给成员变量name进行赋值的
public void setName(String n) {
name = n;
}
//作用：对外提供name属性的
public String getName() {
return name;
}
//age
//setAge:给成员变量age进行赋值的
//getAge:对外提供成员变量age的值
public void setAge(int a) {
if(a>=18&&a<=50){
age=a;
}else{
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
//gender
public void setGender(String g) {
gender = g;
}
public String getGender(){
return gender;
}
// 行为
public void sleep(){
System.out.println("李在睡觉？");
}
public void eat(){
System.out.println("李在吃饭？");
}
}
2.引入
package com.test2;
public class GrilFreindTest {
public static void main(String[] args) {
// 创建对象
GirlFriend gf1 = new GirlFriend();
gf1.setName ("麻瓜");
gf1.setAge(-18);
gf1.setGender("man");
System.out.println(gf1.getName());
System.out.println(gf1.getAge());
System.out.println(gf1.getGender());
gf1.eat();
gf1.sleep();
}
}
对于非法的参数便不会显示
总结：
5.4 this 关键字
package com.test2;
public class GirlFriend {
// 属性
private String name;
private int age;
private String gender;
//针对于每一个私有化的成员变量，都要提供get和set方法
//set方法:给成员变量赋值
//get方法:对外提供成员变量的值
//作用：给成员变量name进行赋值的
public void setName(String name) {
this.name = name;
}
//作用：对外提供name属性的
public String getName() {
return name;
}
//age
//setAge:给成员变量age进行赋值的
//getAge:对外提供成员变量age的值
public void setAge(int age) {
if(age>=18&&age<=50){
this.age=age;
}else{
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
//gender
public void setGender(String gender) {
this.gender = gender;
}
public String getGender(){
return gender;
}
// 行为
public void sleep(){
System.out.println("李在睡觉？");
}
public void eat(){
System.out.println("李在吃饭？");
}
}
5.5 构造方法
5.6 标准的javabean
package test3;
public class User {
private String username;
private String password;
private String email;
private String gender;
private int age;
//空参
public User(){}
//带全部参数的构造
public User(String username,String password,String email,String gender,int age ){
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
//set 方法对内建立形参成的构造
public void setUsername(String username){
this.username = username;
}
//get 方法对外提供Username
public String getUsername(){
return username;
}
}
快捷键一键生成构造
- alt + insert
- alt + Fn + insert
- my 笔记本: alt + Fn + Del
无选择，生成
public User() {
}
public User(String username, String password, String email, String gender, int age) {
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
get和set快速构造
插件PTG 1秒生成标准Javabean
5.6 三种情况的对象内存图
一个对象的内存图：
两个对象的内存图：
两个引用指向同一个对象
5.7 数据类型
基本数据类型在栈里存储的是真实的数据
引用数据类型：数据值是存储在其他空间中,自己空间中存储的是地址值。
从内存角度看：
5.8 this的内存原理
this的本质:所在方法调用者的地址值
5.9 成员和局部
5.10 java中的psvm
主方法的代码: public static void main(String[] args){}
- 它是一个主方法,所以程序执行的入口,它的方法名是不可变化的,因为JVM是通过main()这个方法名来寻找程序的入口的.
- 其次,这个方法是一个使用static关键字修饰的静态方法,因为程序刚开始的时候没办法先创建对象,然后在利用对象调用里面的方法,所以只能使用静态方法通过类名.方法名来调用主方法.
- 访问权限使用public关键字修饰主要是为了确保主方法能够被其他包下面的文件访问到.
- 再看参数列表是一个String类型名称为args的字符串数组,那个这个字符串数组是干什么用的呢?是通过cmd命令提示符编写java程序时,在执行阶段用来接收用户从键盘录入的信息.
public static void main(String[] args) {}