标签：Java Person int 面向对象 打磨 对象 方法 public 属性
面向对象基础
一个程序就是一个世界，有很多事物(对象[属性，行为])
类与对象
类表示一个共性的产物，是一个综合的特征，而对象是一个个性的产物，一个个体的体征
类是对象的一个模板，对象是一个类的一个个体，对应一个实例
类是抽象的，代表一类事物，比如人类，猫类
对象是具体的，实际的，代表一个具体的事物，即是实例
类必须通过对象才可以使用，对象的所有的操作都在类中定义。
类由属性和方法组成：
**属性（成员变量）：**就相当于人的一个个特征，例如眼睛，嘴，鼻子
成员变量 = 属性 = field
属性是类的一个组成部分，一般都是基本数据类型，也可以是引用类型（对象、数组）。
**方法（行为）；**就相当于人的行为，例如说话，放屁，睡觉唱歌
如果类进行实例化操作，必须依靠对象，必须在main主方法
类名称 对象名称 = new 类名称();
cat cat1 = new cat();
上图说明
注意：猫类到对象，目前有几种说法:1.创建对象 2.实例化一个对象 3.把类实例化
Java最大的特点就是面向对象
对象内存布局
**栈：**java的指令区，存放的是程序指令、定义好的常量和长度固定的变量 优点：存取速度比堆快，仅次于寄存器
栈数据可以共享；缺点：存在栈中的数据大小与生命周期必须是确定的，缺乏灵活性。
**堆：**java的数据区，是一个运行时数据区，类的对象从中分配空间，他们不需要程序代码显示的释放，而是由垃圾回收机制来负责的。优势可以动态得分配内存地址，生存期也不必事先告诉编译区，因为它是运行时动态分配内存的，java有自动回收垃圾体制，自动收取不再使用的数据。**缺点：**是由于要在运行时动态分配内存，存取速度较慢
由此可见栈内存的引用变量并没有真正存储对象中的变量数据，对象的变量数据实际放在了堆内存，引用变量只是指向堆内存里的对象。
属性注意事项和细节说明
1.属性的定义语法同变量 如：访问修饰符 属性类型 属性名；
2.属性的定义类型可以为任意类型，包含基本类型或引用类型
3.属性如果不赋值，有默认值，规则和数组一致，具体的说：
int 0，short 0，byte 0，long 0，float 0.0 , double 0,char \u0000,
boolean false,String null;
访问属性
基本语法
对象名.属性名；
对象分配机制
类和对象的内存分配机制
java内存结构分析
1.栈：一般存放基本数据类型（局部变量）
2.堆：存放对象（Cat cat 数组等）
3.方法区：常量池（常量，比如字符串），类加载信息
4.示意图[Cat(name,age,price)]
Java创建对象的流程简单分析
Person p = new Person();
p.name = "jack";
p.age = 10;
1.先加载Person类信息（属性和方法信息，只会加载一次）
2.在堆中分配空间，进行默认初始化（看规则）
3.把地址p，p就指向对象
4.进行指定初始化，比如p.name = “jack” p.age = 10
创建对象流程
public class Person01 {
public static void main(String[] args) {
//创建Person对象
//p1 是对象名（对象引用）
//new Person（）创建的对象空间（数据）才是真正的对象
Person p1 = new Person();
System.out.println(p1.age);
System.out.println(p1.name);
System.out.println(p1.sal);
System.out.println(p1.isPass);
}
}
class Person{
//四个属性
int age;
String name;
double sal;
boolean isPass;
}
成员方法（简称行为）
基本介绍
在某些情况，我们需要定义成员方法，比如人类：除了有一些属性外（年龄，姓名）我们人类还有一些行为比如
说话、跑步、学习，交朋友。现在我们就可以用成员方法来完成
public 表示公开 void：表示方法没有返回值 speak():speak方法名， ()形参列表
{}方法体，可以写我们要执行的代码
System.out.println("我是一个好人")；
表示我们的方法就是输出
一句话
classPerson{
public void speak(){
System.out.println("我是一个好人")；
}
}
方法使用
class Test{
public static void main(String[] args){
Person p1 = newPerson;
p1.speak();
p1.call();
}
}
public void call(){
int res = 0;
for(int i = 1; i<=1000;i++){
res+= i;
}
System.out.println("计算结果="+res);
}
形参使用
public int getsum(int num1,int num2){
int res = num1 + num2;
return res;
}
public static void main(String[] args){
//调用getsum方法，同时num1 = 10; num2 = 20
//吧getsum返回的值赋给变量returnRes
int returnRes = p1.getsum(10,20);
}
成员方法的定义
public 返回数据类型 方法名（参数表…）｛//方法体
语句；
return 返回值；
｝
返回类型注意事项和细节
1.一个方法最多有一个返回值[思考，怎么返回多个结果？]
2.返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）
3.如果方法要求有返回数值类型，则方法体中最后的执行语句必须为return 值
而且要求返回值类型必须和return的值类型一致或兼容
4.如果方法是void，则方法体可以没有return语句，或者只写return；
参数列表注意事项和使用细节
1.一个方法可以有多个0个参数，也可以有多个参数，中间用逗号隔开。getSum（int n1,int n2)
2.参数类型可以为任意类型，包含基本类型或引用类型。printArr(int[ ,][, ] map )
3.调用参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数【getSum】
4.方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，实参和形参的类型
要一致或兼容、个数、顺序必须一致！
方法体
里面写完成的功能的具体的语句，可以输入、输出、变量、运算、分支、循环、方法调用，但里面不能
再定义方法！ 即：方法不能嵌套定义。
方法调用细节注意事项和使用细节
1.同一个类中的方法调用说明：直接调用即可。比如print（参数）；
2.跨类中的方法A类调用B类方法：需要通过对象名调用。
3.跨类的方法调用和方法的访问修饰符相关。
方法调用细节
1.当程序执行到方法时，就会开辟一个独立的空间（栈空间）
2.当方法执行完毕，或者执行到return语句时，就会返回
3.返回到调用发的地方
4.返回后，继续执行方法后面的代码
5.当main方法（栈）执行完毕，整个程序退出
方法传参机制
1.基本数据类型的传参机制
public void swap(int a, int b){
int tmp = a;
a = b;
b = tmp;
System.out.println("a="+a+"\tb="+b);
}
2.结论
基本数据类型， 传递的值是（值拷贝），形参的任何改变不影响实参！
2.引用类型传参机制
public class Method {
public static void main(String[] args) {
//测试
B b= new B();
int[] arr = {1,2,3};
b.test100(arr);
System.out.println("main的arr数组");
//遍历数组
for (int i= 0; i< arr.length;i++){
System.out.println(arr[i]);
}
}
}
class B{
public void test100(int[] arr){
arr[0] = 200;//修改元素
// 遍历B的数组
for (int i = 0;i< arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
看案例B类编写一个方法test100，可以接收一个数组，在方法中修改修改该数组，原来的数组是否
发生改变
2.结论
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参。
方法递归
基本介绍
简单的说：递归就是方法调用自己，每次调用时传入不同的变量；有助于编程者解决复杂问题，让代码变得简洁
递归能解决什么问题？
1.各种数学问题：如8皇后问题、汉诺塔、阶乘问题、迷宫、球和篮子
2.各种算法也会使用到递归，比如快排、归并排序、二分查找、分治算法
3.将用栈解决的问题----》递归代码比较简洁
递归调用机制图
public class jicheng1 {
public static void main(String[] args) {
o o1 = new o();
o1.test(4);
}
}
class o {
public void test(int n) {
if (n > 1) {
test(n - 1);
}
System.out.println("n=" + n);
}
}
public class jicheng1 {
public static void main(String[] args) {
o o1 = new o();
int res = o1.fact(5);
System.out.println("res="+res);
}
}
class o {
public int fact(int n){
if (n==1){
return 1;
}else{
return fact(n-1)*n;
}
}
}
递归注意事项和说明
1.当执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
2.方法的局部变量是独立的，不会相互影响，比如n变量
2.如果方法中使用的是引用变量（比如数组），就会共享引用类型的数据
4.递归必须向退出递归的条件逼近，否则就是无限递归
5.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时执行完毕或者返回时，该方法也就执行完毕。
方法重载
基本介绍
Java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致
好处
1.减轻了起名的麻烦 2.记名的麻烦
使用细节
1.方法名：必须相同
2.参数列表：必须不同（参数类型或个数或顺序，至少一样不同，参数名无要求）
3.返回类型：无要求
public class zaiOne {
public static void main(String[] args) {
Methods rn = new Methods();
System.out.println(rn.max(95,100));
System.out.println(rn.max(25.1,26.3));
System.out.println(rn.max(25.1,26.3,85.2));
}
}
class Methods{
public int max(int n1,int n2){
return n1>n2?n1:n2;
}
public double max(double n1,double n2){
return n1>n2?n1:n2;
}
public double max(double n1,double n2,double n3){
double max1 = n1>n2?n1:n2;
return max1>n3?max1:n3;
}
}
可变参数
基本概念
Java允许将同一个类中多个同名功能但参数个数不同的方法，封装成一个方法
基本语法
访问修饰符 返回类型 方法名（数据类型… 形参名）{
}
注意事项和使用细节
1.可变参数的实参可以为0个或任意多个。
2.可变参数的实参可以为数组。
3.可变参数的本质就是数组。
4.可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5.一个形参列表只能出现一个可变参数
public class zaiOne {
public static void main(String[] args) {
Methods rn = new Methods();
System.out.println(rn.sum(56,25,45,48));
}
}
class Methods{
public int sum(int...nums){
int res = 0;
for (int i= 0;i< nums.length;i++){
res+=nums[i];
}
return res;
}
}
作用域
1.在Java编程中，主要的变量就是属性（成员变量）和局部变量。
2.我们说的局部变量一般是指在成员方法中定义的变量。
3.Java中作用域的分类
**全局变量：**也就是属性，作用域为整个类体Cat类：cry eat 等方法使用属性
**局部变量：**也就是除了属性之外的其他变量，作用域为定义它的代码块中！
4.全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
注意使用和细节
1.属性和局部变量可以重名，访问时遵循就近原则。
2.在同一个作用域中，比如同一个成员方法中，两个局部变量，不能重名。
3.属性生命周期较长，伴随着对象的创建而创建，伴随着对象的死亡而死亡。局部变量，声明周期较短，伴随着他的代码块的执行而创建，伴随着代码块的结束而死亡。就是在一次方法调用过程中。
4.作用域范围不同
全局变量：可以被本类使用，或其他类使用（通过对象调用）
局部变量：只能在本类中对应的方法中使用
5.修饰符不同
全局变量/属性可以加修饰符
局部变量不能加修饰符
构造方法和构造器
基本介绍
构造方法又叫构造器，是类的一种特殊方法，他的主要作用是完成对新对象的初始化
1.方法名和类名必须相同
2.没有返回值
3.在创建对象时，系统会自动调用该类的构造器完成对对象的初始化。
**说明：**构造器的修饰符可以默认，也可以是public、protected、private
参数列表和成员方法一样的规则。
基本语法
修饰符 方法名 （形参列表）{
方法体；
}
注意事项和细节
1.一个类可以定义多个不同的构造器，即构造器重载
2.构造器名和类名要相同
3.构造器没有返回值
4.构造器是完成对象的初始化，并不是创建对象
5.在创建对象时，系统自动的调用该类的构造方法
6.如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法
(也叫默认构造方法)，
7.一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，
除非显示的定义一下
public class zaiThree {
public static void main(String[] args) {
Person p1 = new Person();
System.out.println(p1.name+" "+p1.age);
Person p2 = new Person("刘志成",26);
System.out.println(p2.name+" "+p2.age);
}
}
/**
* 在前面定义的Person类添加两个构造器
* 第一个无参构造器，利用构造器设置所有人的age属性初始值都为18
* 第二个带pname和page两个参数的构造器
* 使得每次创建person对象的同时初始化对象的age属性和name属性
* 分别使用不同的构造器，创建对象*/
class Person{
String name;
int age;
public Person(){
age = 18;
}
public Person(String pname ,int page){
age = page;
name = pname;
}
}
this的使用
介绍
Java虚拟机会给每个对象分配this，代表当前对象。
哪个对象调用，this就代表哪个对象
this的内存分配
this的注意事项和说明
1.this的关键字可以用来访问本类的属性、方法、构造器
2.this用于区分当前类的属性和局部变量
3.访问成员方法的语法：this.方法名(参数列表)；
4.访问构造器语法：this(参数列表)注意：只能在构造器使用(只能在构造器中访问另外一个构造器)；
必须放在第一条语句
5.this不能在类定义的外部使用，只能在类定义的方法使用。
public class zaiThree {
public static void main(String[] args) {
Person p1 = new Person("marry",20);
Person p2 = new Person("marry",30);
//输出p1和p2的比较结果
System.out.println(p1.compareTo(p2));
}
}
class Person{
String name;
int age;
public Person(String name ,int age){
//this访问本类属性
this.name = name;
this.age = age;
}
public boolean compareTo(Person p){
//如果当前属性名字比较局部属性名字 并且 当前年龄 == 局部属性年龄
if (this.name.equals(p.name) && this.age == p.age){
return true;
}else {
return false;
}
}
}
标签：Java,Person,int,面向对象,打磨,对象,方法,public,属性 来源： https://blog.csdn.net/liustreh/article/details/116892477
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。