面向对象

概念:


    1、同一类事物的抽象描述,不是具体的

    2、类和对象的关系:
        类 是抽象的。
        对象 是具体的。
    3、对象的体征,称为“属性”
    4、多个 对象的方法 + 属性 相同 构成一类
6-2 类的编写构成。

语法: 
    [修饰符] class 类名 {

     ...
    }
    注意:    

        1、修饰符可有可无,如果写,类名和文件名必须相同。
        2、类名驼峰命名法。

类的属性-即 成员变量。
    语法格式:
        [修饰符] 数据类型 属性名称

        注意:    

    1、修饰符可有可无
            2、驼峰命名法
            3、不同数据类型,声明后有默认值(仅在成员变量中)。
                默认值
                整数类型:0
                浮点类型:0.0
                字符类型:\u0000 就是空格
                布尔类型:false
                引用类型:null

通常 类的定义和使用分别用两个文件编写
示例代码:Person.java

/**
* @ClassName Person
* @projectName: object1
* @author: Zhangmingda
* @description: XXX
* date: 2021/3/27.
*/
public class Person {
/**
* 名字
*/
public String name; /**
* 年龄
*/
public int age; /**
* 身高
*/
public int height; /**
* 撩妹
*/
public void sayHello(){
System.out.println("Hi 妞,干啥嘞!");
}
}

创建对象

    语法:类名 引用名称(实例名称) = new 类名()
    访问对象中的属性和方法:实例名称.属性名称
    示例代码:

PersonTest.java
/**
* @ClassName PersonTest
* @projectName: object1
* @author: Zhangmingda
* @description: XXX
* date: 2021/3/27.
*/
public class PersonTest {
public static void main(String[] args) {
//类实例化对象
Person person = new Person();
//给对象属性赋值
person.age = 18;
person.name = "张铭达";
person.height = 180;
//调用对象的方法
person.sayHello();
}
}

错误用例:

         示例代码:
class Student{
//属性变量的默认值
String name; //null
int age; //0
double weight; //0.0
char sex; //\u0000 public void print(){
System.out.println(age);
}
/*
public static void main(String[] args){
print(); //错误: 无法从静态上下文中引用非静态 方法 print()
}*/ } //编写测试类
class StudentTest
{ public static void main(String[] args){
Student s1 = new Student();
s1.print();//调用对象的方法
System.out.println(s1.weight + s1.name + s1.sex + s1.weight);//调用(访问对象属性)
}
}

对象是引用数据类型:

举例示意:

一个对象A指赋值给另一个对象B,修改B的属性,A的属性同时被修改;因为B和A指向同一个对象内存地址

代码示例

        Person personA = new Person();
personA.name = "张三";
Person personB = personA;
personB.name = "李四";
System.out.println("personA.name =" + personA.name + "personB.name =" + personB.name );
//输出:personA.name =李四personB.name =李四

 this关键字

this代表当前实例化的对象本身,是一个指向当前对象的一个指针

示例:

/**
* @ClassName Person
* @projectName: object1
* @author: Zhangmingda
* @description: XXX
* date: 2021/3/27.
*/
public class Person {
/**
* 名字
*/
public String name; /**
* 年龄
*/
public int age; /**
* 身高
*/
public int height; /**
* 撩妹
*/
public void sayHello(){
this.beForSayHello();
System.out.println("Hi 妞,干啥嘞!");
} /**
* 另一个方法
*/
public void beForSayHello(){
System.out.println(this.name + "要开始撩骚了");
}
}

测试this关键字,测试类同上

类中变量区别:

    --成员变量:没有赋值时有默认值,数据类型不同,则默认值不同。
    --局部变量:没有初始值,也就是说必须先声明,在赋值,然后才能使用//否则编译错误
        ----局部变量名可以和成员变量同名,方法内调用时就近原则

    示例代码:
class Car{
String id ;
String color ; public void show(){
String id = "冀H D8888";
System.out.println("局部变量:" + id);
System.out.println("实例变量:" + this.id); //方法中引用成员变量,使用this
}
}
class CarTest{
public static void main(String[] args){
Car c1 = new Car(); //实例化类
c1.show();
c1.id = "京 A 00000";
c1.show(); //给实例变量赋值
}
}

方法(函数)

 方法分类
 
   分类:系统方法、用户自定义方法

自定义方法(函数)

    语法格式:
    [修饰符] 返回类型 方法名称([参数列表]){

        方法体
    }

说明:
        1、[] 中的内容可有可无,暂时修饰符 编写为public static
        2、返回类型:
            第一种,无返回类型,写void
            第二种,有返回类型,也就是编写为目前所学 9 中数据类型之一
        3、方法(函数)名称:驼峰命名法

   4、方法要编写在类中

    方法调用:
        格式: 类名.方法名()
        注意: 本类中的类名.可以省略

    调用过程:
        1、方法执行,需先进栈
        2、方法执行完毕,方法出站。
        3、栈特点,先进后出。

示例代码

当形参和类属性相同,比如方法中形参name;类中也有属性name,调用类中属性的name用this

    /**
* 有参数的方法
* @param name
*/
public void sayHelloTo(String name){
this.beForSayHello();
System.out.println(this.name + "对"+ name +"说: Hi 妞,干啥嘞!");
}

使用方法

public class PersonTest {
public static void main(String[] args) {
//类实例化对象
personA.name = "李四";
//测试有参数方法
personA.sayHelloTo("老师");
}
} /**
*输出:
李四要开始撩骚了
李四对老师说: Hi 妞,干啥嘞!
*
*/

形参和实参

形参:方法定义的时候设置需要传递的参数名称

实参:方法调用时传递给方法的具体参数

基础数据类型变量参数

特点:方法内修改传递的变量不会修改原始变量值

原理:每个方法是独立的栈内存区域;不同的栈内存区域变量修改相互独立。

示例代码:

两个变量互换值的工具类

public class ModifyTools {
public void changeNum(int a ,int b){
int tmp = a;
a = b;
b = tmp;
System.out.println("changeNum 动作中 a = " + a + ", b = " + b);
}
}

测试类

public class ModifyToolsTest {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println("测试类 mian方法中 a = " + a + ", b = " + b);
ModifyTools modifyTools = new ModifyTools();
modifyTools.changeNum(a, b);
System.out.println("调用ModifyTools.changeNum()后 测试类mian方法中 a = " + a + ", b = " + b);
}
}
/**
* 输出:
测试类 mian方法中 a = 1, b = 2
changeNum 动作中 a = 2, b = 1
调用ModifyTools.changeNum()后 测试类mian方法中 a = 1, b = 2 */

原理示意图

引用类型变量作为实际参数

比如对象作为参数

参数的修改:将对象传递给另一个对象的方法作为参数。方法修改对象的属性

示例:改变两个人的名字

public class ModifyTools {
public void changeName(Person a, Person b){
String tmpName = a.name;
a.name = b.name;
b.name = tmpName;
System.out.println("changeName 动作后 person1.name = " + a.name + ", person2.name = " + b.name );
} }

测试类main方法中调用

public class ModifyToolsTest {
public static void main(String[] args) {
//测试用另一个类的方法改变对象的属性
Person person1 = new Person();
Person person2 = new Person();
person1.name = "张三";
person2.name = "李四";
System.out.println("测试类main方法中初始化 person1.name = " + person1.name + ", person2.name = " + person2.name );
ModifyTools modifyTools1 = new ModifyTools();
modifyTools.changeName(person1, person2);
System.out.println("测试类main方法中 person1.name = " + person1.name + ", person2.name = " + person2.name );
}
}
/**
输出
测试类main方法中初始化 person1.name = 张三, person2.name = 李四
changeName 动作后 person1.name = 李四, person2.name = 张三
测试类main方法中 person1.name = 李四, person2.name = 张三
*/

 原理:

对象属于引用数据类型, 传参将对象传参实际是将指向的的内存地址传递给处理类

不定长参数传递

语法:<参数类型>... <参数名>

释义:参数类型后面紧跟三个英文的点符号 然后写参数名

注意:有固定参数和不定长参数同时存在时,需要将不定长参数放在形参最后

示例:Person类中sayHelloToGirls方法

public class Person {
/**
* 名字
*/
public String name; /**
*
* @param content 要说话的内容
* @param names 可变长参数:N个人的名字
* 注意:不定长参数必须放在定长形式参数后面(本例:names 必须在content后面)
*/
public void sayHelloToGirls(String content, String... names){
for(String name: names){
System.out.println(this.name + " 对" + name + "说:" + content);
}
}
}

测试用例

public class PersonTest {
public static void main(String[] args) {
//测试不定长参数传递
Person personV = new Person();
personV.name = "V哥";
personV.sayHelloToGirls("我很喜欢你哦","小爱", "晓丽", "晓弘", "蔡依林");
}
}
/**
* 输出结果:
V哥 对小爱说:我很喜欢你哦
V哥 对晓丽说:我很喜欢你哦
V哥 对晓弘说:我很喜欢你哦
V哥 对蔡依林说:我很喜欢你哦
*/

返回值

可以是基本数据类型 或者 是引用数据类型(比如自定义的类)

示例:

方法add 对多个int类型的数字求和:返回值类型为int

public class ModifyTools {
/**
*
* @param nums N个int类型数字
* @return 求和结果
*/
public int add(int... nums){
int count = 0;
for(int num : nums){
count +=num;
}
return count;
}
}

测试类

public class ModifyToolsTest {
public static void main(String[] args) {
//测试有返回值的方法
ModifyTools modifyTools2 = new ModifyTools();
int num1 = 1;
int num2 = 3;
int num3 = 5;
int result = modifyTools2.add(num1, num2, num3);
System.out.println("求和计算结果为:" + result);
}
}
/**
输出:
求和计算结果为:9
*/

递归方法

就是自己调用自己

示例:数学中数列的通项公式

例如数学题:有一个数列: f(0) = 1,  f(1) = 4, f(n+2) = 2 * f(n) + f(n+1) ;求f(10) 的值

代码:

/**
* @ClassName RecursionExercise
* @projectName: object1
* @author: Zhangmingda
* @description: XXX
* date: 2021/3/27.
*/
public class RecursionExercise {
public int fn(int n){
/**
*@描述
*@参数 [n] 求数列的第几项
*@返回值 int 第几项的值
*@创建时间 2021/3/27
*@修改人和其它信息
*/
if(n < 0){
System.out.println(n + "小于0是错误的");
return -1;
}else if(n == 0){
return 1;
}else if(n == 1){
return 4;
}else {
// f(n+2) = 2 * f(n) + f(n+1)
// f(n) = 2 * f(n -2) + f(n - 1)
//递归方法自己调用自己
return 2 * fn(n -2) + fn(n - 1);
}
}
}

递归方法测试类

public class RecursionExerciseTest {
public static void main(String[] args) {
RecursionExercise recursionExercise = new RecursionExercise();
int fn10 = recursionExercise.fn(10);
System.out.println(fn10);
}
}
/**
输出:1706
*/

类方法

个人理解使用static修饰的方法就是类方法

Java面向对象~类和对象&方法,类方法的更多相关文章

  1. Java面向对象-类与对象

    Java面向对象-类与对象 类与对象的关系 我们通俗的举个例子,比如人类是一种类,张三这个人就是人类的具体的一个个体,也就是java中的对象:这就是一个类与对象的关系: 类的定义 下面看实例 类的创建 ...

  2. Java面向对象——类,对象和方法

    1.类的概念 在生活中,说到类,可以联想到类别,同类,会想到一类人,一类事物等等.而这一类人或事物都是具有相同特征或特点和行为的,我们根据不同的特征或特点和行为将他们归类或分类.同时,当我们认识一个新 ...

  3. Java面向对象 类与对象与方法的储存情况

    栈.堆.方法区 类(含方法)储存在方法区 main函数入栈 堆里面存储方法区中类与方法的地址 main函数调用方法,找堆里面方法的地址,再从方法区找到对应函数,函数入栈,用完出栈 总结: 1.类.方法 ...

  4. java 面向对象 — 类和对象

    构造方法 1.构造器必须与类同名(如果一个源文件中有多个类,那么构造器必须与公共类同名) 2.每个类可以有一个以上的构造器 3.构造器可以有0个.1个或1个以上的参数 4.构造器没有返回值 5.构造器 ...

  5. Java面向对象类与对象整理

    第一章           面向对象: 1.1         什么是面向过程: 遇到某件事的时候,思考 “我该怎么做”然后一步一步实现的过程 1.2         什么是面向对象: 遇到某件事的时 ...

  6. Java面向对象--类和对象

    面向对象是相对于面向过程而言的,是软件开发方法.面向对象把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统设计,更贴近事物的自然运行模式.本篇博客介绍Java面向对象的类和对象 目录: 面 ...

  7. Java自学-类和对象 方法重载

    什么是Java 方法重载 方法的重载指的是方法名一样,但是参数类型不一样 步骤 1 : attack方法的重载 有一种英雄,叫做物理攻击英雄 ADHero 为ADHero 提供三种方法 public ...

  8. Java面向对象---类与对象的关系

    类是对某一类事物的描述,是抽象的.概念上的意义.对象是实际存在的该类事物的每一个个体,也被称为实例. 创建对象:包括声明对象和实例化对象 Person person;//声明 person = new ...

  9. Java面向对象--类的对象之间的几种关系详解

    转载: https://www.cnblogs.com/supren/p/7853377.html

随机推荐

  1. ant的xml解释

    ant必须以<project>开始和</project>结束 --project(父节点) --target(子节点) ---javac(孙节点) ---echo(孙节点)

  2. 贪心/构造/DP 杂题选做

    本博客将会收录一些贪心/构造的我认为较有价值的题目,这样可以有效的避免日后碰到 P7115 或者 P7915 这样的题就束手无策进而垫底的情况/dk 某些题目虽然跟贪心关系不大,但是在 CF 上有个 ...

  3. CF 786 E ALT

    CF 786 E ALT 一个居民有两个选择:分配一只宠物,路上都有宠物 一个守卫有两种选择:分配一只宠物,不分配宠物 我们找一个原点,到每个居民都有一条边,表示是否给他宠物 从每个居民向他路上的守卫 ...

  4. Jvarkit : Java utilities for Bioinformatics

    Jvarkit : Java utilities for Bioinformatics :一个java写的生物信息工具包:http://lindenb.github.io/jvarkit/

  5. you crash I crash

    今天一大早起来,zabbix报错了 我去查看了mysql的状态 MySQL is not running, but lock file (/var/lock/subsys/mysql) exists ...

  6. Nginx编译参数详细介绍

    /configure --help --help 显示本提示信息 --prefix=PATH 设定安装目录 --sbin-path=PATH 设定程序文件目录 --conf-path=PATH 设定配 ...

  7. OpenSSH 密码和公钥认证原理探究

    目录 配置和保护SSH H3 - 使用SSH 访问远程命令行 H4 - 什么是OpenSSH ? H4 - 登录方式: H4 - 登录并执行临时命令: H4 - 查看登录用户 H4 - 登录原理 密码 ...

  8. 在Telegraf上报的监控数据中添加固定的标签列

    Telegraf作为InfluxData提供的TICK工具栈(由Telegraf, InfluxDB, Chronograf, Kapacitor四个工具的首字母组成)中收集监控数据的一环,功能非常强 ...

  9. hadoop-uber作业模式

    如果作业很小,就选择和自己在同一个JVM上运行任务,与在一个节点上顺序运行这些任务相比,当application master 判断在新的容器中的分配和运行任务的开销大于并行运行它们的开销时,就会发生 ...

  10. 零基础学习java------36---------xml,MyBatis,入门程序,CURD练习(#{}和${}区别,模糊查询,添加本地约束文件) 全局配置文件中常用属性 动态Sql(掌握)

    一. xml  1. 文档的声明 2. 文档的约束,规定了当前文件中有的标签(属性),并且规定了标签层级关系 其叫html文档而言,语法要求更严格,标签成对出现(不是的话会报错) 3. 作用:数据格式 ...