目录
一.类与对象
1.引入
一个问题：杰哥养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户 输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 杰哥没有这只猫猫。
public class Object {
public static void main(String[] args) {
//单独变量=>不利于数据的管理(信息分散)
String cat1Name ="小白";
int cat1Age = 3;
String cat1Color ="白色";
String cat2Name="小花";
int cat2Age = 100;
String cat2Color ="花色";
//数组 ===>数据类型模糊,获取数据时需要用下标,不直观
String[] cat1 = { "小白", "3", "白色"};
String[] cat2 = { "小花", "100", "花色"};
}
}
处理类似问题时，可以使用单独定义各种变量并赋值，或使用数组解决。但是这种方法存在不利于数据管理且效率低下的问题，Java设计者引入类与对象（OOP）处理。
2.类与对象的关系
*从类到对象，目前有几种说法：1.创建一个对象 2.实例化一个对象 3.把类实例化
//定义一个猫类
class Cat {
//属性/成员变量
String name; //名字
int age; //年龄
String color; //颜色
double weight; //体重
//行为
}
public class Object {
public static void main(String[] args) {
//1. new Cat() 创建一只猫(猫对象)
//2. Cat cat1 = new Cat(); 把创建的猫赋给
//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;
//怎么访问对象的属性呢
System.out.println("第 1 只猫信息" + cat1.name + " " + cat1.age +
" " + cat1.color + " " + cat1.weight);
System.out.println("第 2 只猫信息" + cat2.name + " " + cat2.age +
" " + cat2.color + " " + cat2.weight);
}
}3.类与对象的区别和联系
- 类是抽象的，概念的，代表一类事物,比如人类,猫类, 即它是数据类型.
- 对象是具体的，实际的，代表一个具体事物, 即 是实例.
- 类是对象的模板，对象是类的一个个体，对应一个实例
4.对象在内存中的存在形式
（注意区分引用类型和基本类型在内存中的存放方式和位置）
5.属性/成员变量/字段
1）从概念或叫法上看： 成员变量 = 属性 = field(字段) （即 成员变量是用来表示属性的）
class Car {
String name;//属性, 成员变量, 字段 field
double price;
String color;
String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)
}2) 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类 的 int age 就 是属性
*关于属性的细节
- 属性的定义语法同变量类似，如：访问修饰符 属性类型 属性名;
- 访问修饰符： 控制属性的访问范围 有四种访问修饰符 public, proctected, 默认, private
- 属性的定义类型可以为任意类型，包含基本类型或引用类型
- 属性如果不赋值，有默认值，规则和数组一致。具体为: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000， boolean false，String null
//创建 Person 对象
//p1 是对象名(对象引用)
//new Person() 创建的对象空间(数据) 才是真正的对象
Person p1 = new Person();6.创建对象与访问属性
// 1) 先声明再创建
Cat cat ; //声明对象
cat cat = new Cat(); //创建
//2) 直接创建
Cat cat = new Cat();
//对象名.属性名-->访问
cat.name ;
cat.age;
cat.color;7.类和对象的内存分配机制
1）Java 内存的结构分析
- 栈： 一般存放基本数据类型(局部变量)
- 堆： 存放对象(Cat cat , 数组等)
- 方法区：常量池(常量，比如字符串)， 类加载信息
2）创建对象的流程简单分析
Person p = new Person();
p.name = “jack”;
p.age = 10- 先加载 Person 类信息(属性和方法信息, 只会加载一次)
- 在堆中分配空间, 进行默认初始化(看规则)
- 把地址赋给 p
- 进行指定初始化， 比如 p.name =”jack” p.age = 1
二.成员方法
1.引入
在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名..),我们人类还有一 些行为比如:可以说话、跑步..,通过学习，还可以做算术题。这时就要用成员方法才能完成。
1) 提高代码的复用性
2) 可以将实现的细节封装起来，然后供其他用户来调用即可
public class Method {
//编写一个 main 方法
public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
Person p1 = new Person();
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 Person {
//属性
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;
}
}2.成员方法调用机制(栈)
- 当程序执行到方法时，就会开辟一个独立的空间（栈空间）（压栈）
- 当方法执行完毕，或者执行到return语句时，就会返回（弹栈）
- 返回的位置为调用该方法的地方
- 返回后继续执行方法后面的代码
- 当main方法执行完毕，整个程序退出
*成员方法定义细节
- 访问修饰符 (作用是控制 方法使用的范围) 如果不写默认访问，[有四种: public, protected, 默认, private]
- 一个方法最多有一个返回值
- 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
- 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
- 如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return
- 方法不能嵌套定义
*成员方法调用细节
- 同一个类中的方法调用：直接调用即可、
- 跨类中的方法 A 类调用 B 类方法：需要通过对象名调用，且与访问修饰符有关
3.成员方法传参机制
1）基本数据类型的传参机制
基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参
2）引用类型的传参机制
引用类型传递的是地址（传递的也是值，但是值是地址），可以通过形参影响实参
3）成员方法返回类型是引用类型
实例 克隆对象
/*编写一个方法，可以复制一个Person对象，返回复制的对象，
注意要求得到的新对象和原来的对象是两个独立的对象，仅属性相同*/
public class Method {
public static void main(String[] args) {
Person People= new Person();
People.age=18;
People.name="Leon";
People.salary=99999.9;
Person newPeople = People.copyPerson(People);
System.out.println(People.age+" "+ People.salary +" "+ People.name);
System.out.println(newPeople.age+" "+ newPeople.salary +" "+ newPeople.name);
//验证 可以通过对象比较是否为同一个
//输出true就是同一个，false就不是
System.out.println(newPeople==People);
}
}
class Person{
String name;
int age;
double salary;
public Person copyPerson(Person Leon){
Person newLeon= new Person();
newLeon.salary= Leon.salary;
newLeon.name= Leon.name;
newLeon.age= Leon.age;
return newLeon;
}
}
4.方法递归调用
递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁
//阶乘
public int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n - 1) * n;
}
}递归的重要规则
- 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立的，不会相互影响,比如n变量
- 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据
- 递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)
- 当一个方法执行完毕，或者遇到return，就会返，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
ex.1 Fibonacci数列
import java.util.Scanner;
public class Fibonacci {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("input the number");
int n=input.nextInt();
Fib fuc=new Fib();
for (int i=1;i<=n;i++) {
System.out.print(fuc.Fibonacci(i)+" ");
}
}
}
class Fib{
public int Fibonacci(int n){
if (n<=2)
return 1;
else
return (Fibonacci(n-1)+Fibonacci(n-2));
}
}
ex.2 猴子吃桃问题
import java.util.Scanner;
public class monkeyPeach {
public static void main(String[] args) {
CLASS fun=new CLASS();
Scanner in=new Scanner(System.in);
System.out.println("input the day");
int day=in.nextInt();
System.out.println("第"+day+"天有"+fun.eat(day)+"个桃子");//求第一天的桃子数量
}
}
class CLASS{
public int eat(int n){
if(n==10)
return 1;
else
return (eat(n+1)+1)*2;//当天的数量等于第二天的数量加一乘二
}
}
三.方法重载（Overload）
1.基本概念
java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
2.重载注意事项
- 方法名 : 必须相同
- 形参列表: 必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
- 返回类型: 无要求
public class OverLoad {
public static void main(String[] args) {
Methods me=new Methods();
System.out.println(me.max(32,65));
System.out.println(me.max(3.2,6.5));
System.out.println(me.max(3.2,1.0,6.5));
}
}
class Methods{
public int max(int x,int y){
if(y>x){
return y;
}else
return x;
}
public double max(double x,double y){
if(y>x){
return y;
}else
return x;
}
public double max(double x,double y,double z){
if(y>x&&y>z)
return y;
else if (z>y&&z>x) {
return z;
}else
return x;
}
}四.可变参数
1.基本概念
java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。 就可以通过可变参数实现
2.基本语法
访问修饰符 返回类型 方法名(数据类型... 形参名) { }
public class val {
public static void main(String[] args) {
Methods me=new Methods();
System.out.println(me.max(1,2,3,4,5,6));
}
}
class Methods{
public int max(int...x){
//表示可以接收多个int
// x可以当作数组使用
System.out.println("接受的int数量"+x.length);
//遍历求和
int res=0;
for(int i=0;i<x.length;i++){
res+=x[i];
}
return res;
}
}五.作用域
全局变量也就是属性，作用域为整个类体，局部变量一般是指在成员方法中定义的变量
属性在定义时，可以直接赋值
全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值
六.构造方法/构造器
1.基本语法
构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
- 方法名和类名相同
- 没有返回值
- 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化
- 如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
- 一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下
2.基本语法
[修饰符] 方法名(形参列表){ 方法体; }
class Person {
String name;
int age;
public Person(String pName, int pAge) {
System.out.println("构造器被调用，完成对象的属性初始化");
name = pName;
age = pAge;
}七.this关键字
Java虚拟机会给每个对象分配this，代表当前对象
- this 关键字可以用来访问本类的属性、方法、构造器
- this 用于区分当前类的属性和局部变量
- 访问成员方法的语法：this.方法名(参数列表)
- 访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一 条语句)
- this 不能在类定义的外部使用，只能在类定义的方法中使用
public class ThisExercise {
public static void main(String[] args) {
Person P = new Person("Bob", 23);
TestPerson Tp = new TestPerson("Bob", 23);
System.out.println(P.compareTo(Tp));
}
}
class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public Boolean compareTo(TestPerson p) {
// if (this.name.equals(p.name)&&this.age==p.age){
// return true;
// }else {
// return false;
// }
return this.name.equals(p.name) && this.age == p.age;
}
}
class TestPerson {
String name;
int age;
TestPerson(String name, int age) {
this.name = name;
this.age = age;
}
}
734
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
