目录
面向对象
- java是一门面向对象的语言,在java思想里一切皆对象
- 面向对象:Object Oriented Programming
- 面向过程:Procedure Oriented Programming
- 面向过程——步骤化
- 面向过程就是分析出实现需求所需要的步骤,通过函数(方法)一步一步实现这些步骤,接着依次 调用即可。
- 面向对象——行为化(概念相对抽象 )
- 面向对象是把整个需求按照特点、功能划分,将这些存在共性的部分封装成类(类实例化后才是对 象),让对象去解决对应的问题
类和对象的概念:
1. 从概念或叫法上看:成员变量=属性=field (即 成员变量是用来表示属性的,授课中,统一叫属性)
2. 属性是类的一个组成部分,一般是基本数据类型,也可是引用数据类型(对象、数组)创建对象的步骤:
1、创建一个对象
2、实例化一个对象
3、把类实例化
对象内存布局(内存分析图)非常重要!!!
为了加深印象:
分析一个练习题,并分析画出内存分析图,进行分析
Person a = new Person();
a.age = 10;
a.name = "小明";
Person b;
b = a;
System.out.println(b.name);
b.age = 200;
b = null;
System.out.println(a.age);
System.out.println(b.age);
在某些情况下我们需要定义成员方法(简称方法)
小知识:
1. public: 表示方法是公开
2. void : 表示方法没有返回值
3. speak(): speak 是方法名,() 形参列表
4. { } 方法体,可以写我们要执行的代码
5. int : 表示方法执行后,返回一个 int 值
6. (int num1 ,int num2) 形参列表,2个形参,可以接收用户传入的两个数
7. return res:表示 res 的值,返回
成员方法注意事项和使用细节
参数列表
- 一个方法可以有0个参数,也可以有多个参数,中间用逗号隔开 , 比如:
getSum ( int n1 , int n2 )
- 参数类型可以为任意类型,包含基本类型或引用类型
printArr (int [][] map )
- 调用带参数的方法时,一定对应着参数传入相同类型或兼容类型 的参数
byte b1 = 1;
byte b2 = 2;
a.getSumAndSub(b1 ,b2);//byte -> int
a.getSumAndSub(1.1 ,1.8);// double ->int ( × )
- 实参和形参的类型要一致或兼容、个数、顺序必须一致
a.getSumAndSub(100);//个数不一致
a.f3("tom", 10);//ok
a.f3(100, "jack");//实际参数和形式参数顺序不对
- 方法不能嵌套定义
class AA {
public void f4() {
//细节:方法不能嵌套定义
public void f5() {
}
}
public void f3(String str, int n) {
}
}
- 同一个类中的方法调用 : 直接调用即可
案例演示:sayOk 调用 print()
public class Method03 {
public static void main(String[] args) {
A a = new A();
a.sayOk();
}
}
class A {
//同一个类中的方法调用 : 直接调用即可
public void print(int n) {
System.out.println("print()方法被调用 n = " + n);
}
public void sayOk() { // sayOk 调用 print (直接调用即可)
print(10);
System.out.println("继续执行sayOk()");
}
}
- 跨类中的方法A类中调用B类方法:需要通过对象名调用
public static void main(String[] args) {
A a = new A();
a.m1();
}
class A {
//同一个类中的方法调用 : 直接调用即可
public void m1() {
System.out.println("m1 () 方法被调用 ");
//创建B对象,然后再调用方法即可
B b = new B();
b.hi();
System.out.println("m1() 继续执行: ");
}
}
class B{
public void hi(){
System.out.println("B类中的hi()被执行");
}
}
结果:
练习1:
编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ,返回 boolean
思路:
* 1. 方法的返回类型 boolean * 2. 方法的名字 isOdd * 3. 方法的形参 (int num) * 4. 方法体,判断
public class MethodExercise01 {
public static void main(String[] args) {
AA a = new AA();
if (a.isOdd(7)) {
System.out.println("是奇数");
} else {
System.out.println("是偶数");
}
}
}
//编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ,返回 boolean
class AA {
/*思路 ;
* 1. 方法的返回类型 boolean
* 2. 方法的名字 isOdd
* 3. 方法的形参 (int num)
* 4. 方法体,判断 */
public boolean isOdd(int num) {
// 第一种写法
if (num % 2 !=0 ){
return true;
}else {
return false;
}
//第二种写法
return num % 2 != 0;
}
}
结果:
练习2:
根据 行 、 列 、 字符 打印 对应行数和列数的字符 比如 : 行: 4 列: 4 字符 # ,则打印相应的效果
思路: * 1. 方法的返回类型 void * 2. 方法的名字 print * 3. 方法的形参 (int row , int col , char c ) * 4. 方法体,循环
public class MethodExercise01 {
public static void main(String[] args) {
AA a = new AA();
// if (a.isOdd(7)) {
// System.out.println("是奇数");
// } else {
// System.out.println("是偶数");
// }
//使用 print 方法
a.print(4,4,'#');
}
}
//编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ,返回 boolean
class AA {
/*思路 ;
* 1. 方法的返回类型 boolean
* 2. 方法的名字 isOdd
* 3. 方法的形参 (int num)
* 4. 方法体,判断 */
public boolean isOdd(int num) {
// 第一种写法
// if (num % 2 !=0 ){
// return true;
//
// }else {
// return false;
// }
//第二种写法(不知道什么原因报错)
// return num % 2 != 0 ? true; false;
//第三种
return num % 2 != 0;
}
// 根据 行 、 列 、 字符 打印 对应行数和列数的字符
//比如 : 行: 4 列: 4 字符 # ,则打印相应的效果
/*思路 ;
* 1. 方法的返回类型 void
* 2. 方法的名字 print
* 3. 方法的形参 (int row , int col , char c )
* 4. 方法体,循环 */
public void print(int row, int col, char c) {
for (int i=0;i<row;i++){
for (int j=0;j<col;j++){//输出每一行
System.out.print(c);
}
System.out.println();//换行
}
}
}
结果:
基本数据类型的传参机制:
练习:
public class MethodParameter01 {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 创建 AA 对象
AA1 obj = new AA1();
obj.swap(a, b); //调用 swap
System.out.println("a=" + a + "b=" + b);
}
}
class AA1 {
public void swap(int a, int b) {
System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);
//完成了 a 和 b 的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);
}
}
结果:
引用数据类型的传参机制
看一个案例 : B 类中编写一个方法 teat 100 ,可以接收 一个数组 ,在方法中修改该数组, 看看 原来的数组是否有变化? 会变化
public class MethodParameter02 {
public static void main(String[] args) {
BB b = new BB();
int[] arr = {1, 2, 3};
b.test100(arr);// 调用方法
System.out.println("main 的 arr 数组");
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();//换行
}
}
class BB {
//看一个案例 : B 类中编写一个方法 teat 100 ,
// 可以接收 一个数组 ,在方法中修改该数组, 看看 原来的数组是否有变化?
//
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();//换行
}
结论:引用类型传递的是地址(传递也是值 ,但是 值是地址) , 可以通过形参影响实参!
结果 :
B类中编写一个方法 test 200 ,可以接收一个 Person(age ,sal ) 对象,在方法中修改该对象属性 ,看看原来的对象是否变化?会变化
public class MethodParameter02 {
public static void main(String[] args) {
BB b = new BB();
Person p = new Person();
p.name = "javk";
p.age=10;
b.test200(p);
System.out.println("main 的p.age ="+p.age);
}
}
class Person1 {
String name;
int age;
}
class BB {
public void test200(Person p) {
p.age = 10000;//修改对象属性
}
}
结果:
练习:
编写一个方法 copyPerson , 可以复制一个Person对象 ,返回复制的对象 (克隆对象) 注意要求得到新对象和原来的对象是两个独立的对象,只是它们的属性相同
思路:
1 方法的返回类型 Person
2 方法的名字 copyPerson
3 方法的形参 (Person p)
4. 方法体。创建一个新对象 ,并复制属性 ,返回即可
public class MethodExercise02 {
public static void main(String[] args) {
Person p = new Person();
p.name = "milan";
p.age = 100;
//创建 tools
MyTools1 tools1=new MyTools1();
Person p2 = tools1.copyPerson(p);
//到此 p he p2 是 Person 对象 , 但是 是两个独立的对象 ,属性相同
System.out.println("p 的属性 age ="+ p.age + "名字 " + p.name);
System.out.println("p 的属性 age ="+ p2.age + "名字 " + p2.name);
// 这里提示 : 可以同对象比较 看看是否同为一个对象 hashCode
System.out.println(p==p2);//false
}
}
class Person2 {
String name;
int age;
}
class MyTools1 {
public Person copyPerson(Person p) {
//创建一个新的对象
Person p2 = new Person();
p2.name = p.name;//把原来对象的名字赋给 p2 . name
p2.age = p.age;//把原来对象的年龄赋给 p2 . age
return p2;
}
}
结果: