面向对象编程（初级）
类与对象
看一个养猫猫问题:
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。
请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。
使用现有技术解决:
单独的定义变量解决
使用数组解决
单独的定义变量解决:
import java.util.Scanner;
public class Object01 {
public static void main(String[] args) {
//第1只猫信息
String cat1Name = "小白";
int cat1Age = 3;
String cat1Color = "白色";
//第2只猫信息
String cat2Name = "小花";
int cat2Age = 100;
String cat2Color = "花色";
Scanner myScanner = new Scanner(System.in);
System.out.println("输入小猫的名字：");
String findName = myScanner.next();
if (findName.equals(cat1Name)){
System.out.println("猫信息：" + cat1Name
+ " " + cat1Age + " " + cat1Color);
} else if(findName.equals(cat2Name)){
System.out.println("猫信息：" + cat2Name
+ " " + cat2Age + " " + cat2Color);
} else {
System.out.println("张老太没有这只猫猫");
}
}
}
使用数组解决:
import java.util.Scanner;
public class Object01 {
public static void main(String[] args) {
//第1只猫信息
String[] cat1 = {"小白", "3", "白色"};
//第2只猫信息
String[] cat2 = {"小花", "100", "花色"};
int cat2Age = 100;
String cat2Color = "花色";
Scanner myScanner = new Scanner(System.in);
System.out.println("输入小猫的名字：");
String findName = myScanner.next();
if (findName.equals(cat1[0])){
System.out.println("猫信息：" + cat1[0] + cat1[1] + cat1[2]);
} else if(findName.equals(cat1[0])){
System.out.println("猫信息：" + cat2[0] + cat2[1] + cat2[2]);
} else {
System.out.println("张老太没有这只猫猫");
}
}
}
现有技术解决的缺点分析:
不利于数据的管理 效率低 ---> 引出 类与对象
Java 设计者 引入 类与对象(OOP) ，根本原因就是现有的技术，不能完美的解决新的新的需求。
import java.util.Scanner;
public class Object01 {
public static void main(String[] args) {
//使用OOP面向对象解决
//实例化一只猫[创建一只猫对象]
//1. new Cat() 创建一只猫(猫对象)
//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1
//3. cat1 就是一个对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 10;
//创建了第二只猫，并赋给 cat2
//cat2 也是一个对象(猫对象)
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
cat2.weight = 20;
//访问对象的属性
Scanner myScanner = new Scanner(System.in);
System.out.println("输入小猫的名字：");
String findName = myScanner.next();
if (findName.equals(cat1.name)) {
System.out.println("第1只猫信息：" + cat1.name
+ " " + cat1.age + " " + cat1.color + " " + cat1.weight);
} else if (findName.equals(cat2.name)) {
System.out.println("第2只猫信息：" + cat2.name
+ " " + cat2.age + " " + cat2.color + " " + cat2.weight);
} else {
System.out.println("张老太没有这只猫猫");
}
}
}
//使用面向对象的方式来解决养猫问题
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
//属性/成员变量
String name; //名字
int age; //年龄
String color; //颜色
double weight; //体重
//行为
}
一个程序就是一个世界，有很多事物(对象[属性, 行为])
注意:从猫类到对象，目前有几种说法:
创建一个对象
实例化一个对象
把类实例化...
类和对象的区别和联系
类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型
对象是具体的，实际的，代表一个具体事物, 即 是实例
类是对象的模板，对象是类的一个个体，对应一个实例
对象在内存中存在形式
属性/成员变量/字段
基本介绍
从概念或叫法上看： 成员变量 = 属性 = field(字段) （即成员变量是用来表示属性的，授课中，统一叫属性)
属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类 的 int age 就是属性
注意事项和细节说明
属性的定义语法同变量，示例：访问修饰符 属性类型 属性名;
这里简单的介绍访问修饰符： 控制属性的访问范围有四种访问修饰符 public, proctected, default(默认),private属性的定义类型可以为任意类型，包含基本类型或引用类型
属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
如何创建对象
先声明再创建
Cat cat ; //声明对象 cat
cat = new Cat(); //创建直接创建 Cat cat = new Cat();
如何访问属性
基本语法:
对象名.属性名;
案例演示赋值和输出 cat.name ; cat.age ; cat.color ;
类和对象的内存分配机制
Java 内存的结构分析:
栈： 一般存放基本数据类型(局部变量)
堆： 存放对象(Cat cat , 数组等)
方法区：常量池(常量，比如字符串)， 类加载信息
Person p1=new Person();
p1.age=10;
p1.name="小明";
Person p2=p1; //把p1 赋给了 p2 ， 让p2指向p1
System.out.println(p2.age); // 80
Java 创建对象的流程简单分析: Person p = new Person(); p.name = "jack"; p.age = 10;
先加载 Person 类信息(属性和方法信息, 只会加载一次)
在堆中分配空间, 进行默认初始化(看规则)
把地址赋给 p , p 就指向对象
进行指定初始化， 比如 p.name ="jack" p.age = 10
成员方法
基本介绍:
在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名..),我们人类还有一 些行为比如:可以说话、跑步..,通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类完善。
成员方法快速入门
添加 speak 成员方法,输出 “我是一个好人” 2) 添加 cal01 成员方法,可以计算从 1+..+1000 的结果
加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果
添加 getSum 成员方法,可以计算两个数的和
public class Method01 {
public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
Person2 p1 = new Person2();
p1.speak(); //调用方法
p1.cal01(); //调用cal01方法
p1.cal02(5); //调用cal02方法，同时给n = 5
p1.cal02(10); //调用cal02方法，同时给n = 10
//调用getSum方法，同时num1=10, num2=20
//把 方法 getSum 返回的值，赋给 变量 returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum方法返回的值=" + returnRes);
}
}
class Person2 {
String name;
int age;
//方法(成员方法)
//添加speak 成员方法,输出 “我是一个好人”
//1. public 表示方法是公开
//2. void ： 表示方法没有返回值
//3. speak() : speak是方法名， () 形参列表
//4. {} 方法体，可以写我们要执行的代码
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
public void speak() {
System.out.println("我是一个好人");
}
//添加cal01 成员方法,可以计算从 1+..+1000的结果
public void cal01() {
//循环完成
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01方法 计算结果=" + res);
}
//添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
public void cal02(int n) {
//循环完成
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02方法 计算结果=" + res);
}
//添加getSum成员方法,可以计算两个数的和
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
方法的调用机制原理：
成员方法的好处
提高代码的复用性
可以将实现的细节封装起来，然后供其他用户来调用即可
成员方法的定义
访问修饰符 返回数据类型 方法名（形参列表..{//方法体
语句；
return 返回值;
}
形参列表：表示成员方法输入 cal(int n)，getSum(int num1, int num2)
返回数据类型：表示成员方法输出, void 表示没有返回值
方法主体：表示为了实现某一功能代码块
return 语句不是必须的。
注意事项和使用细节
访问修饰符 (作用是控制 方法使用的范围)
如果不写默认访问，[有四种: public, protected, 默认, private]
返回数据类型
一个方法最多有一个返回值 [如何返回多个结果 返回数组]
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
方法名:
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如 得到两个数的和 getSum, 开发中按照规范
形参列表
一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如 getSum(int n1,int n2)
参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(int[][] map)
调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!(getSum)
方法定义时的参数称为形式参数，简称形参;方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致!
方法体
里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。
方法调用细节说明(!!!)
同一个类中的方法调用:直接调用即可。比如print(参数);
跨类中的方法A类调用B类方法:需要通过对象名调用。比如对象名.方法名(参数);
特别说明一下:跨类的方法调用和方法的访问修饰符相关。
成员方法传参机制(非常非常重要)
基本数据类型的传参机制
public class MethodParameter01 {
public static void main(String[] args) {
int a = 10;
int b = 20;
//创建BB对象 名字 obj
BB obj = new BB();
obj.swap(a,b);//调用swap
System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20
}
}
class BB {
public void swap(int a,int b){
System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了 a 和 b的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
}
}
结论：基本数据类型，传递的是值(值拷贝)，形参的任何改变不影响实参!
引用数据类型的传参机制
类中编写一个方法，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？会变化
类中编写一个方法 test200，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化？会变化
public class MethodParameter02 {
public static void main(String[] args) {
C c = new C();
int[] arr = {1, 2, 3};
c.test100(arr);
System.out.println(" main的 arr数组 ");
//遍历数组
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
//测试
person2 p = new person2();
p.name = "jack";
p.age = 10;
c.test200(p);
//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
//测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是10
System.out.println("main 的p.age=" + p.age);
}
}
class person2 {
String name;
int age;
}
class C {
public void test200(person2 p) {
p.age = 10000; //修改对象属性
//思考
p = new person2();
p.name = "tom";
p.age = 99;
//思考
//p = null;
}
//C类中编写一个方法test100，
//可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
public void test100(int[] arr) {
arr[0] = 200;//修改元素
//遍历数组
System.out.println(" test100的 arr数组 ");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
}
}
结论：引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！
例：编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象， 注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
public class MethodExercise02 {
public static void main(String[] args) {
Person p = new Person();
p.name = "milan";
p.age = 100;
//创建tools
Mytools tools = new Mytools();
Person p2 = tools.copyPerson(p);
//到此 p 和 p2是Person对象，但是是两个独立的对象，属性相同
System.out.println("p的属性 age=" + p.age + " 名字=" + p.name);
System.out.println("p2的属性 age=" + p2.age + " 名字=" + p2.name);
//提示： 可以同 对象比较看看是否为同一个对象
System.out.println(p == p2);//false
}
}
//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，
//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
//
//编写方法的思路
//1. 方法的返回类型 Person
//2. 方法的名字 copyPerson
//3. 方法的形参 (Person p)
//4. 方法体, 创建一个新对象，并复制属性，返回即可
class Person {
String name;
int age;
}
class Mytools {
public Person copyPerson(Person p){
Person p2 = new Person();
p2.name = p.name;
p2.age = p.age;
return p2;
}
}
方法递归调用
基本介绍：
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量。递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
public class Recursion01 {
public static void main(String[] args) {
T t1 = new T();
t1.test(4);//输出什么？ n=2 n=3 n=4
int res = t1.factorial(5);
System.out.println("5的阶乘 res =" + res);
}
}
class T {
//分析
public void test(int n) {
if (n > 2) {
test(n - 1);
}
System.out.println("n=" + n);
}
//factorial 阶乘
public int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n - 1) * n;
}
}
}
递归重要规则
执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响,比如n变量
如果方法中使用的是引用类型变量(比如数组，对象)，就会共享该引用类型的数据
递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁,同时当方法执行完毕或者返回时，该方法也就执行完毕。
public class RecursionExercise01 {
public static void main(String[] args) {
TT t1 = new TT();
int n = 7;
int res = t1.fibonacci(n);
if(res != -1) {
System.out.println("当n="+ n +" 对应的斐波那契数=" + res);
}
}
}
class TT {
/*
请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...
给你一个整数n，求出它的值是多少
思路分析
1. 当n = 1 斐波那契数 是1
2. 当n = 2 斐波那契数 是1
3. 当n >= 3 斐波那契数 是前两个数的和
4. 这里就是一个递归的思路
*/
public int fibonacci(int n) {
if (n >= 1) {
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
} else {
System.out.println("要求输入的n>=1的整数");
return -1;
}
}
}
递归调用应用实例-迷宫问题
public class MiGong {
public static void main(String[] args) {
//思路
//1. 先创建迷宫，用二维数组表示 int[][] map = new int[8][7];
//2. 先规定 map 数组的元素值: 0 表示可以走 1 表示障碍物
int[][] map = new int[8][7];
//3. 将最上面的一行和最下面的一行，全部设置为1
for(int i = 0; i < 7; i++) {
map[0][i] = 1;
map[7][i] = 1;
}
//4.将最右面的一列和最左面的一列，全部设置为1
for(int i = 0; i < 8; i++) {
map[i][0] = 1;
map[i][6] = 1;
}
map[3][1] = 1;
map[3][2] = 1;
//输出当前的地图
System.out.println("=====当前地图情况======");
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");//输出一行
}
System.out.println();
}
//使用findWay给老鼠找路
M m1 = new M();
m1.findWay(map, 1, 1);
System.out.println("\n====找路的情况如下=====");
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");//输出一行
}
System.out.println();
}
}
}
class M {
//使用递归回溯的思想来解决老鼠出迷宫
//1. findWay方法就是专门来找出迷宫的路径
//2. 如果找到，就返回 true ,否则返回false
//3. map 就是二维数组，即表示迷宫
//4. i,j 就是老鼠的位置，初始化的位置为(1,1)
//5. 因为我们是递归的找路，所以我先规定 map数组的各个值的含义
// 0 表示可以走 1 表示障碍物 2 表示可以走 3 表示走过，但是走不通是死路
//6. 当map[6][5] =2 就说明找到通路,就可以结束，否则就继续找.
//7. 先确定老鼠找路策略 下->右->上->左
public boolean findWay(int[][] map, int i, int j) {
if (map[6][5] == 2) {//说明已经找到
return true;
} else {
if (map[i][j] == 0) {//当前这个位置0,说明表示可以走
//我们假定可以走通
map[i][j] = 2;
//使用找路策略，来确定该位置是否真的可以走通
//下->右->上->左
if (findWay(map, i + 1, j)) {//先走下
return true;
} else if (findWay(map, i, j + 1)) {//右
return true;
} else if (findWay(map, i - 1, j)) {//上
return true;
} else if (findWay(map, i, j - 1)) {//左
return true;
} else {
map[i][j] = 3;
return false;
}
} else { //map[i][j] = 1 , 2, 3
return false;
}
}
}
}
递归调用应用实例-汉诺塔
public class HanoiTower {
public static void main(String[] args) {
Tower tower = new Tower();
tower.move(5, 'A', 'B', 'C');
}
}
class Tower{
//方法
//num 表示要移动的个数, a, b, c 分别表示A塔，B 塔, C 塔
public void move(int num , char a, char b ,char c){
//如果只有一个盘 num = 1
if(num == 1) {
System.out.println(a + "->" + c);
} else {
//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
//(1)先移动上面所有的盘到 b, 借助 c
move(num - 1 , a, c, b);
//(2)把最下面的这个盘，移动到 c
System.out.println(a + "->" + c);
//(3)再把 b塔的所有盘，移动到c ,借助a
move(num - 1, b, a, c);
}
}
}
递归调用应用实例-八皇后问题
public class Queen {
public static void main(String[] args) {
Q q = new Q();
q.put(0);
System.out.println("解法：" + q.count);
}
}
class Q{
int max = 8;//一共有max个皇后
int[] arr = new int[max];//数组arr用来保存皇后位置
int count = 0;//统计解法个数
public void print(){
count++;
for (int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("=================");
}
public boolean judge(int n){
for (int i = 0; i < n; i++){
if (arr[i] == arr[n] || Math.abs(n - i) == Math.abs(arr[n] - arr[i])){
return false;//在同一列或者同一斜线上时返回false
}
}
return true;
}
public void put(int n){//放置皇后
if (n == max){
print();
return;
}
//依次放入皇后并判断
for (int i = 0; i < max ; i++){
//先把当前皇后放到该行的第一列
arr[n] = i;
//判断放置第n个皇后到第i列时是否冲突
if (judge(n)){
put(n + 1);
}
}
}
}
方法重载(OverLoad)
Java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！ 比如：System.out.println(); out 是 PrintStream 类型
重载的好处:
减轻了起名的麻烦
减轻了记名的麻烦
注意事项和使用细节
方法名:必须相同
形参列表:必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
返回类型:无要求
public class OverLoadExercise {
public static void main(String[] args) {
//在主类的main ()方法中分别用参数区别调用三个方法
Methods method = new Methods();
method.m(10);//100
method.m(10, 20);//200
method.m("hello");//字符串信息
System.out.println(method.max(10, 24)); // 24
System.out.println(method.max(10.0, 21.4)); // 21.4
System.out.println(method.max(10.0, 1.4, 30.0)); // 30.0
}
}
/*
编写程序，类Methods中定义三个重载方法并调用。方法名为m。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，
相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法
定义三个重载方法max()，第一个方法，返回两个int值中的最大值，
第二个方法，返回两个double值中的最大值，
第三个方法，返回三个double值中的最大值，并分别调用三个方法
*/
class Methods{
//分析
//1 方法名 m
//2 形参 (int)
//3.void
public void m(int n){
System.out.println("平方=" + (n * n));
}
//1 方法名 m
//2 形参 (int, int)
//3.void
public void m(int n1, int n2) {
System.out.println("相乘=" + (n1 * n2));
}
//1 方法名 m
//2 形参 (String)
//3.void
public void m(String str) {
System.out.println("传入的str=" + str);
}
//分析
//1 方法名 max
//2 形参 (int,int)
//3.int
public int max(int n1, int n2) {
return n1 > n2 ? n1 : n2;
}
//分析
//1 方法名 max
//2 形参 (double,double)
//3.double
public double max(double n1, double n2) {
return n1 > n2 ? n1 : n2;
}
//分析
//1 方法名 max
//2 形参 (double,double,double)
//3.double
public double max(double n1, double n2, double n3) {
//System.out.println("max(double n1, double n2, double n3)");
//求出n1 和 n2的最大值
double max1 = n1 > n2 ? n1 : n2;
return max1 > n3 ? max1 : n3;
}
}
可变参数
基本概念:
Java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现
基本语法:
访问修饰符 返回类型 方法名(数据类型... 形参名) { }
public class VarParameter {
public static void main(String[] args) {
fyxMethod m =new fyxMethod();
System.out.println(m.sum(1, 5, 100)); //106
System.out.println(m.sum(1,19)); //20
}
}
class fyxMethod{
//1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int... nums) {
//System.out.println("接收的参数个数=" + nums.length);
int res = 0;
for(int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
注意事项和使用细节
可变参数的实参可以为0个或任意多个。
可变参数的实参可以为数组。
可变参数的本质就是数组。
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。
一个形参列表中只能出现一个可变参数。
public class VarParameterDetail {
public static void main(String[] args) {
int[] arr = {1,2,3};
V v1 = new V();
v1.f1(arr);
}
}
class V {
public void f1(int... nums) {
System.out.println("长度=" + nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void f2(String str, double... nums) {
}
//细节: 一个形参列表中只能出现一个可变参数
//下面的写法是错的.
// public void f3(int... nums1, double... nums2) {
// }
}
public class VarParameterExercise {
public static void main(String[] args) {
fMethod fm = new fMethod();
System.out.println(fm.showScore("milan",90,80.0));
System.out.println(fm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
}
}
class fMethod{
/*
有三个方法，分别实现返回姓名和两门课成绩(总分)，
返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
封装成一个可变参数的方法
*/
//分析1. 方法名 showScore 2. 形参(String ,double... ) 3. 返回String
public String showScore(String name, double...scores){
double totalScore = 0.0;
for (int i = 0; i < scores.length; i++){
totalScore += scores[i];
}
return name + " 有 " +scores.length + "门课的成绩总分为=" + totalScore;
}
}
作用域
在java编程中，主要的变量就是属性(成员变量)和局部变量。
我们说的局部变量一般是指在成员方法中定义的变量。【举例Cat类: cry】
java中作用域的分类 全局变量:也就是属性，作用域为整个类体 Cat类:cry eat等方法使用属性。
局部变量:也就是除了属性之外的其他变量，作用域为定义它的代码块中!全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
public class VarScope {
public static void main(String[] args) {
}
}
class Cat1 {
//全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
//属性在定义时，可以直接赋值
int age = 10; //指定的值是 10
//全局变量(属性)可以不赋值，直接使用，因为有默认值，
double weight; //默认值是0.0
public void hi() {
//局部变量必须赋值后，才能使用，因为没有默认值
int num = 1;
String address = "北京的猫";
System.out.println("num=" + num);
System.out.println("address=" + address);
System.out.println("weight=" + weight);//属性
}
public void cry() {
//1. 局部变量一般是指在成员方法中定义的变量
//2. n 和 name 就是局部变量
//3. n 和 name的作用域在 cry方法中
int n = 10;
String name = "jack";
System.out.println("在cry中使用属性 age=" + age);
}
public void eat() {
System.out.println("在eat中使用属性 age=" + age);
//System.out.println("在eat中使用 cry的变量 name=" + name);//错误
}
}
注意事项和细节使用：
属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，比如在同一个成员方法中,两个局部变量，不能重名。
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量,生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
作用域范围不同 全局变量/属性:可以被本类使用，或其他类使用(通过对象调用)局部变量:只能在本类中对应的方法中使用
修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符
public class VarScopeDetail {
public static void main(String[] args) {
person1 p1 = new person1();
/*
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，
伴随着代码块的结束而销毁。即在一次方法调用过程中
*/
//当执行say方法时,say方法的局部变量比如name,会创建,
//当say执行完毕后,name局部变量就销毁,但是属性(全局变量)仍然可以使用.
//p1.say();
T1 t1 = new T1();
t1.test();
t1.test2(p1);
}
}
class T1 {
//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
public void test() {
person1 p1 = new person1();
System.out.println(p1.name);//jack
}
public void test2(person1 p) {
System.out.println(p.name);//jack
}
}
class person1 {
//细节: 属性可以加修饰符(public protected private..)
// 局部变量不能加修饰符
public int age = 20;
String name = "jack";
public void say() {
//细节 属性和局部变量可以重名，访问时遵循就近原则
//String name = "king";
System.out.println("say() name=" + name);
}
public void hi() {
String address = "北京";
//String address = "上海";//错误,重复定义变量
String name = "fyx";//可以
}
}
构造方法/构造器
我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。
基本语法:
[修饰符] 方法名(形参列表){
方法体;
}
说明：
构造器的修饰符可以默认， 也可以是 public protected private
构造器没有返回值
方法名 和类名字必须一样
参数列表 和 成员方法一样的规则
构造器的调用, 由系统完成
基本介绍:
构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
注意事项和使用细节
一个类可以定义多个不同的构造器，即构造器重载
比如:我们可以再给Person类定义一个构造器,用来创建对象时,只指定人名,不需要指定年龄构造器名和类名要相同
构造器没有返回值
构造器是完成对象的初始化并不是创建对象
在创建对象时,系统自动的调用该类的构造方法
如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器).比如Dog(){},使用javap指令反编译看看
一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下,即:Dog(){}(这点很重要)
对象创建流程分析 
加载Person类信息(Person.class).只会加载一次
在堆中分配空间(地址)
完成对象初始化[ 3.1默认初始化age=0 name=null 3.2显式初始化age=90,name=null, 3.3构造器的初始化 age =20, name=小倩]
在对象在堆中的地址,返回给p(p是对象名,也可以理解成是对象的引用)
this关键字
Java虚拟机会给每个对象分配this,代表当前对象。
public class This01 {
//编写一个main方法
public static void main(String[] args) {
Dog1 dog1 = new Dog1("大壮", 3);
System.out.println("dog1的hashcode=" + dog1.hashCode());
//dog1调用了 info()方法
dog1.info();
System.out.println("============");
Dog1 dog2 = new Dog1("大黄", 2);
System.out.println("dog2的hashcode=" + dog2.hashCode());
dog2.info();
}
}
class Dog1{ //类
String name;
int age;
// public Dog(String dName, int dAge){//构造器
// name = dName;
// age = dAge;
// }
//如果我们构造器的形参，能够直接写成属性名，就更好了
//但是出现了一个问题，根据变量的作用域原则
//构造器的name 是局部变量，而不是属性
//构造器的age 是局部变量，而不是属性
//==> 引出this关键字来解决
public Dog1(String name, int age){//构造器
//this.name 就是当前对象的属性name
this.name = name;
//this.age 就是当前对象的属性age
this.age = age;
System.out.println("this.hashCode=" + this.hashCode());
}
public void info(){//成员方法,输出属性x信息
System.out.println("this.hashCode=" + this.hashCode());
System.out.println(name + "\t" + age + "\t");
}
}
简单的说，哪个对象调用，this就代表哪个对象
this 的注意事项和使用细节
this 关键字可以用来访问本类的属性、方法、构造
this 用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名(参数列表);
访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
this 不能在类定义的外部使用，只能在类定义的方法中使用。
public class ThisDetail {
public static void main(String[] args) {
// D t1 = new D();
// t1.f2();
D t2 = new D();
t2.f3();
}
}
class D {
String name = "jack";
int num = 100;
/*
细节: 访问构造器语法：this(参数列表);
注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)
注意： 访问构造器语法：this(参数列表); 必须放置第一条语句
*/
public D() {
//这里去访问 D(String name, int age) 构造器
this("jack", 100);
System.out.println("D() 构造器");
}
public D(String name, int age) {
System.out.println("D(String name, int age) 构造器");
}
//this关键字可以用来访问本类的属性
public void f3() {
String name = "smith";//局部变量
//传统方式 就近原则(看是不是有局部变量)
System.out.println("name=" + name + " num=" + num);//smith 100
//也可以使用this访问属性
System.out.println("name=" + this.name + " num=" + this.num);//jack 100
}
//细节: 访问成员方法的语法：this.方法名(参数列表);
public void f1() {
System.out.println("f1() 方法..");
}
public void f2() {
System.out.println("f2() 方法..");
//调用本类的 f1
//第一种方式
f1();
//第二种方式
this.f1();
}
}
作业
编写类A01，定义方法max，实现求某个double数组的最大值，并返回
public class Homework01 {
public static void main(String[] args) {
A01 a01 = new A01();
double[] arr = {1, 1.4, -1.3, 89.8, 123.8 , 66};
Double res = a01.max(arr);
if(res != null) {
System.out.println("arr的最大值=" + res);
} else {
System.out.println("arr的输入有误, 数组不能为null, 或者{}");
}
}
}
/*
编写类A01，定义方法max，实现求某个double数组的最大值，并返回
思路分析
1. 类名 A01
2. 方法名 max
3. 形参 (double[])
4. 返回值 double
先完成正常业务，然后再考虑代码健壮性
*/
class A01{
public Double max(double[] arr) {
//先判断arr是否为null,然后再判断 length 是否>0
if (arr != null && arr.length > 0) {
//保证arr至少有一个元素
double max = arr[0];//假定第一个元素就是最大值
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
} else {
return null;
}
}
}
编写类A02，定义方法find，实现查找某字符串是否在字符串数组中，并返回索引，如果找不到，返回-1
public class Homework02 {
public static void main(String[] args) {
String[] strs = {"jack", "tom", "mary","milan"};
A02 a02 = new A02();
int index = a02.find("milan", strs);
System.out.println("查找的index=" + index);
}
}
//编写类A02，定义方法find，实现查找某字符串是否在字符串数组中，
//并返回索引，如果找不到，返回-1
//分析
//1. 类名 A02
//2. 方法名 find
//3. 返回值 int
//4. 形参 (String , String[])
class A02{
public int find(String findStr, String[] strs) {
//直接遍历字符串数组，如果找到，则返回索引
for(int i = 0; i < strs.length; i++) {
if(findStr.equals(strs[i])) {
return i;
}
}
//如果没有，就返回-1
return -1;
}
}
编写类Book, 定义方法updatePrice，实现更改某本书的价格， 具体：如果价格>150,则更改为150，如果价格>100,更改为100，否则不变
public class Homework03 {
public static void main(String[] args) {
Book book= new Book("笑傲江湖", 300);
book.info();
book.updatePrice();//更新价格
book.info();
}
}
/*
编写类Book, 定义方法updatePrice，实现更改某本书的价格，
具体：如果价格>150,则更改为150，如果价格>100,更改为100，否则不变
分析
1. 类名 Book
2. 属性 price, name
3. 方法名 updatePrice
4. 形参 ()
5. 返回值 void
6. 提供一个构造器
*/
class Book{
double price;
String name;
public Book(String name, double price){
this.name = name;
this.price = price;
}
public void updatePrice(){
if (this.price > 150){
this.price = 150;
} else if (this.price > 100){
this.price = 100;
}
}
//显示书籍情况
public void info() {
System.out.println("书名=" + this.name + " 价格=" + this.price);
}
}
编写类A03, 实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样
public class Homework04 {
public static void main(String[] args) {
int[] oldArr = {10, 30, 50};
A03 a03 = new A03();
int[] newArr = a03.copyArr(oldArr);
//遍历newArr,验证
System.out.println("==返回的newArr元素情况==");
for(int i = 0; i < newArr.length; i++) {
System.out.print(newArr[i] + "\t");
}
}
}
//编写类A03, 实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样
class A03{
public int[] copyArr(int[] oldArr) {
//在堆中，创建一个长度为 oldArr.length 数组
int[] newArr = new int[oldArr.length];
//遍历 oldArr,将元素拷贝到 newArr
for(int i = 0; i < oldArr.length; i++) {
newArr[i] = oldArr[i];
}
return newArr;
}
}
定义一个圆类Circle, 定义属性：半径，提供显示圆周长功能的方法， 提供显示圆面积的方法
public class Homework05 {
public static void main(String[] args) {
Circle circle = new Circle(3);
System.out.println("面积=" + circle.area());
System.out.println("周长=" + circle.len());
}
}
//定义一个圆类Circle, 定义属性：半径，提供显示圆周长功能的方法，提供显示圆面积的方法
class Circle{
double radius;
public Circle(double radius) {
this.radius = radius;
}
public double len(){
return 2 * Math.PI * radius;
}
public double area(){
return Math.PI * radius * radius;
}
}
编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示) 并创建两个对象，分别测试
public class Homework06 {
public static void main(String[] args) {
Cale cale = new Cale(2, 10);
System.out.println("和=" + cale.sum());
System.out.println("差=" + cale.minus());
System.out.println("乘=" + cale.mul());
Double divRes = cale.div();
if(divRes != null) {
System.out.println("除=" + divRes);
}
}
}
/*
编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示) 并创建两个对象，分别测试
*/
class Cale{
double num1;
double num2;
public Cale(double num1, double num2) {
this.num1 = num1;
this.num2 = num2;
}
//和
public double sum(){
return num1 + num2;
}
//差
public double minus(){
return num1 - num2;
}
//乘
public double mul(){
return num1 * num2;
}
//商
public Double div() {
//判断
if(num2 == 0) {
System.out.println("num2 不能为0");
return null;
} else {
return num1 / num2;
}
}
}
设计一个Dog类，有名字、颜色和年龄属性，定义输出方法show()显示其信息。并创建对象，进行测试
public class Homework07 {
public static void main(String[] args) {
Dog2 dog2 = new Dog2("tom","黄色",2);
dog2.show();
}
}
//设计一个Dog类，有名字、颜色和年龄属性，定义输出方法show()显示其信息。
//并创建对象，进行测试
class Dog2{
String name;
String color;
int age;
public Dog2(String name,String color,int age){
this.name = name;
this.color = color;
this.age = age;
}
public void show(){
System.out.println("=====信息=====");
System.out.println(this.name + "\t" +this.color + "\t" + this.age + "\t");
}
}
观察程序
public class Test { //公有类
int count = 9; //属性
public void count1() { //Test类的成员方法
count=10;//这个count就是属性 改成 10
System.out.println("count1=" + count); //10
}
public void count2() { //Test类的成员方法
System.out.println("count1=" + count++);
}
//这是Test类的main方法, 任何一个类，都可有main
public static void main(String args[]) {
//1. new Test() 是匿名对象， 匿名对象使用后，就不能使用
//2. new Test().count1() 创建好匿名对象后, 就调用count1()
new Test().count1();
Test t1= new Test();
t1.count2();
t1.count2();
}
}
定义Music类，里面有音乐名name、音乐时长times属性， 并有播放play功能和返回本身属性信息的功能方法getInfo
public class Homework09 {
public static void main(String[] args) {
Music music = new Music("笑傲江湖", 300);
music.play();
System.out.println(music.getInfo());
}
}
//定义Music类，里面有音乐名name、音乐时长times属性，
//并有播放play功能和返回本身属性信息的功能方法getInfo
class Music{
String name;
int times;
public Music(String name,int times){
this.name = name;
this.times = times;
}
public void play(){
System.out.println("音乐 " + name + " 正在播放中.... 时长为" + times + "秒");
}
public String getInfo(){
return "音乐 " + name + " 播放时间为" + times;
}
}
创建一个Employee类， 属性有(名字，性别，年龄，职位，薪水)， 提供3个构造方法，可以初始化
(1) (名字，性别，年龄，职位，薪水), (2) (名字，性别，年龄) (3) (职位，薪水), 要求充分复用构造器
public class Homework11 {
public static void main(String[] args) {
}
}
/*
创建一个Employee类，
属性有(名字，性别，年龄，职位，薪水)， 提供3个构造方法，可以初始化
(1) (名字，性别，年龄，职位，薪水),
(2) (名字，性别，年龄) (3) (职位，薪水), 要求充分复用构造器
*/
class Employee{
String name;
char gender;
int age;
String job;
double sal;
//因为要求可以复用构造器，因此先写属性少的构造器
//职位，薪水
public Employee(String job, double sal){
this.job = job;
this.sal = sal;
}
//名字，性别，年龄
public Employee(String name, char gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
//名字，性别，年龄，职位，薪水
public Employee(String job, double sal, String name, char gender, int age) {
this(name, gender, age);//使用到 前面的 构造器
this.job = job;
this.sal = sal;
//this(job,sal);//错误，因为在构造器中访问另外一个构造器, 必须放在第一条语句
}
}
题目要求： (1) 定义一个Circle类，包含一个double型的radius属性代表圆的半径，findArea()方法返回圆的面积。 (2) 定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下： public void printAreas(Circle c, int times) //方法签名/声明 (3) 在printAreas方法中打印输出1到times之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。 (4) 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。
public class Homework12 {
public static void main(String[] args) {
Circle c = new Circle();
PassObject po = new PassObject();
po.printAreas(c, 5);
}
}
/*
题目要求：
(1) 定义一个Circle类，包含一个double型的radius属性代表圆的半径，findArea()方法返回圆的面积。
(2) 定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
public void printAreas(Circle c, int times) //方法签名/声明
(3) 在printAreas方法中打印输出1到times之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
(4) 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。
*/
class Circle{
double radius;
public Circle() { //无参构造器
}
public Circle(double radius) {
this.radius = radius;
}
public double findArea(){
return Math.PI * radius * radius;
}
//添加方法setRadius, 修改对象的半径值
public void setRadius(double radius) {
this.radius = radius;
}
}
class PassObject{
public void printAreas(Circle c, int times){
System.out.println("Radius\tArea");
for (int i = 1; i <= times; i++){//输出1到times之间的每个整数半径值
c.setRadius(i) ; //修改c 对象的半径值
System.out.println((double)i + "\t" + c.findArea());
}
}
}
本文章使用limfx的vscode插件快速发布