JAVA面向对象(基础总结)
|
文章
|
210

4099 字
|
1.1 小时
本文最后更新于162 天前，其中的信息可能已经过时，如有错误请发送邮件到big_fw@foxmail.com

方法

方法的使用

1.概述

拥有功能性代码的代码块,我们将来一个功能就应该定义一个方法
将来开发一个功能就应该对应搞一个方法,而不是将所有的功能相关代码放在一个方法中
到时候执行哪个功能就单独调用哪个方法

2.方法定义各部分解释:

1.方法的通用定义格式:
  修饰符 返回值类型 方法名(参数){
      方法体
      return 结果
  } 

2.各部分解释:
  a.修饰符: 固定为public static
  b.返回值类型: 方法执行完毕之后最终返回的数据的数据类型
    比如:return 1 -> 返回值类型为int
        return 2.5 -> 返回值类型为double
        return "5hysec" -> 返回值类型为String
  c.方法名:给方法取的名字 -> 见名知意
  d.参数:数据类型 变量名,数据类型 变量名 -> 用于接收别人传递过来的数据
  e.方法体:实现这个方法的具体代码
  f.return 结果 -> 方法运行之后最终的结果,将其返回 -> 返回值

3.在通用格式的基础上,分成四种方法

//无参无返回值方法定义和调用
1.格式:
public static void 方法名(){
方法体
}
2.注意:
void关键字代表的是无返回值,如果此方法没有返回值,返回值类型上写void,就不要写具体的返回值数据类型了

3.调用:
在其他方法中:方法名();

//有参数无返回值的方法定义和执行流程
1.格式:
public static void 方法名(参数){
方法体
}

2.直接调用:
方法名(具体得值)


//无参数有返回值定义以及执行流程
1.格式:
public static 返回值类型 方法名(){
方法体
return 结果
}

2.调用:
a.赋值调用: 数据类型 变量名 = 方法名() -> 推荐使用
b.打印调用: sout(方法名()) -> 不推荐使用

//有参数有返回值定义以及执行流程

1.格式:
public static 返回值类型 方法名(参数){
方法体
return 结果
}

2.调用:
a.赋值调用: 数据类型 变量名 = 方法名(具体的值)

4.形参和实参的区别

  • 形参(形式参数):在定义方法的时候,形式上定义的参数,此时并没有值
  • 实参(实际参数):在调用方法的时候,给形参传递的具体的值

5.参数和返回值使用的时机

  • 参数:当想将一个方法中的数据传递到另外一个方法中,那么被调用方法需要定义参数,调用时传递想要传递过去的数据
  • 返回值:调用方法时,想要此方法的结果,去参与其他操作,那么被调用的方法需要将自己的结果返回

6.注意:

  • 方法不调用不执行
  • 方法之间是平级关系,不能互相嵌套
  • 方法的执行顺序只和调用顺序有关
  • main方法是jvm自动调用
  • void不能和[return 结果]共存,但是void能和[return]共存
  • void:代表无返回值
  • return 结果:代表有返回值 -> 先将结果返回,然后结束方法
  • return:仅仅代表结束方法,不代表有返回值
  • 方法的调用必须完全匹配(参数个数,类型,顺序等)
  • 一个方法中只能有一个返回值,不要连续写多个return

方法的重载(Overload)

1.概述—方法名相同,参数列表不同的方法

2.什么叫做参数列表不同

  • 参数个数不同
  • 参数类型不同
  • 参数顺序不同

3.和什么无关

  • 和返回值无关
  • 和变量名无关

4.使用场景:功能一样,实现细节不一样,就可以定义重载的方法

5.例子

1.需求:定义三个方法,分别求两个数的和,三个数的和,四个数的和
public class Demo06OverLoad {
    public static void main(String[] args) {
         sum(10,20);
         sum(10,20,30);
    }

    public static void sum(int a,int b){
        int sum = a+b;
        System.out.println("sum = " + sum);
    }

    public static void sum(int a,int b,int c){
        int sum = a+b+c;
        System.out.println("sum = " + sum);
    }

    public static void sum(int a,int b,int c,int d){
        int sum = a+b+c+d;
        System.out.println("sum = " + sum);
    }
}

面向对象

面向对象三大特征:
封装 继承 多态

  1. 什么是面向对象思想:java的核心编程思想
  2. 为什么要使用面向对象思想编程:有很多功能别人都写好了我们直接创建这个对象,直接拿过来用我们的功能就能实现 -> 懒-> 为了少写代码
  3. 什么时候要使用面向对象思想编程:在一个类中想使用别的类实现好的功能时,就需要使用面向对象思想编程了
  4. 怎么使用面向对象思想编程:
    • a.new呀,点呀
    • b.特殊:调用带static关键字的 -> 直接类名点

类

1.类的概述:一类事物的抽象表示形式

2.类的分类

a.实体类 -> 世间万物的分类
b.测试类 -> 带main方法的类 -> 为了测试代码是否能跑通的类

3.实体类包含两部分:

属性(这个分类有啥)-> 成员变量
a.定义格式: 数据类型 变量名
b.定义位置: 类中方法外
c.成员变量有默认值:
整数 0
小数 0.0
字符 ‘\u0000’
布尔 false
引用 null

行为(这个分类能干啥,有什么功能) -> 成员方法
将之前的方法干掉static关键字,其他的一样

public class Person {
    //属性 -> 成员变量
    String name;
    int age;

    //行为 -> 成员方法
    public void eat(){
        System.out.println("人要吃饭");
    }

    public void drink(){
        System.out.println("人要喝水");
    }

    public void la(){
        System.out.println("人要出恭");
    }

    public void sa(){
        System.out.println("人要嘘嘘");
    }
}

对象

1.概述:一类事物的具体体现

2.使用:

a.导包:import 包名.类名
如果两个类不在同一个包下,使用对方的成员就需要导包
如果两个类在同一个包下,使用对方的成员就不需要导包

b.创建对象:想要调用哪个类的成员,就new哪个类的对象
类名 对象名 = new 类名()

c.调用成员(成员方法,成员变量)
对象名.成员变量名 = 值
对象名.方法名()

public class Person {
    //属性 -> 成员变量
    String name;
    int age;

    //行为 -> 成员方法
    public void eat(){
        System.out.println("人要吃饭");
    }

    public void drink(){
        System.out.println("人要喝水");
    }

    public void la(){
        System.out.println("人要出恭");
    }

    public void sa(){
        System.out.println("人要嘘嘘");
    }
}
public class Demo02Object {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);

        person.name = "涛哥";
        person.age = 18;
        System.out.println(person.name);
        System.out.println(person.age);

        person.eat();
        person.drink();
        person.la();
        person.sa();
    }
}

3.匿名对象的使用

1.匿名对象:

new对象的时候,没有等号左边,只有等号右边的new对象部分
有名对象:Person p = new Person()
匿名对象:new Person()

2.使用:

new Person().成员名

3.优缺点:

a.优点:好使用
b.缺点大大的:对象不能循环使用,浪费内存

4.注意:

a.如果我们想临时的调用一次方法,我们可以使用匿名对象
b.但是如果涉及到赋值,千万不要使用

public class Demo01 {
    public static void main(String[] args) {
        //有名对象
        Person p = new Person();
        p.eat();
        p.drink();

        System.out.println("=================");

        //匿名对象
        new Person().eat();
        new Person().drink();
    }
}

成员变量和局部变量区别

1.定义位置不同:
a.成员变量:类中方法外
b.局部变量:方法内部,或者参数位置上
2.初始化值不同:
a.成员变量:是有默认值的,不需要赋值就能直接使用
b.局部变量:没有默认值的,必须先初始化才能使用
3.作用范围不同:
a.成员变量:作用于整个类
b.局部变量:只作用于自己所在的方法内部
4.内存位置不同:
a.成员变量:在堆中,因为成员变量跟着对象走
b.局部变量:在栈中,因为局部变量跟着方法走
5.生命周期不同:
a.成员变量:随着对象的创建而创建,随着对象的消失而消失
b.局部变量:随着方法的执行而创建,随着方法的弹栈而消失

public class Person {
    String name;//成员变量

    public void eat(){
        //局部变量
        int i = 10;
        System.out.println(i);

        int j;
        //System.out.println("j = " + j);

        System.out.println(name);
    }

    public void drink(){
        System.out.println(name);
        //System.out.println(i);
    }
}

封装

1.封装的介绍及使用

1).封装怎么用:

a.将代码放到一个方法中,方法体就是我们隐藏起来的细节,方法名就是对外提供的公共接口 -> 我们直接通过调用方法名,方法内部的细节就执行了,至于这个方法怎么实现的,我们无需关注,我们只关注调用方法

b.将成员私有化 -> private
private -> 代表的是私有的,被私有化的成员只能在自己当前类中使用

private可以修饰成员变量,也可以修饰方法

2).封装总结一句话:将细节隐藏起来(不让外界直接使用),对外提供一套公共的接口(供外界通过这个公共的接口间接使用隐藏起来的细节)

(1).用private修饰成员之后(相当于隐藏细节)
(2).提供getxxx/setxxx方法(相当于对外提供的公共接口)
  a.setxxx:为属性赋值
  b.getxxx:获取属性值
public class Person {
    private String name;
    private int age;

    /**
     * 针对私有化的name提供getxxx/setxxx方法
     */
    public void setName(String xingMing) {
        name = xingMing;
    }

    public String getName() {
        return name;
    }

    public void setAge(int nianLing) {
        if (nianLing <= 0) {
            System.out.println("年龄不合法");
        } else {
            age = nianLing;
        }
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "萌姐";
        //person.age = 38;
        //System.out.println(person.name);
        //System.out.println(person.age);
        person.setName("萌姐");
        person.setAge(-38);

        String name = person.getName();
        int age = person.getAge();
        System.out.println(name+"..."+age);

    }
}

2.this的介绍

1.注意:当成员变量和局部变量重名的时候,遵循”就近原则”,先走局部变量
2.this关键字:
a.概述:代表的是当前对象
b.用法:this.成员的
3.this代表的是当前对象,具体代表哪个当前对象呢?
哪个对象调用的this所在的方法,this就代表哪个对象

public class Person {
     String name;
     public void speak(String name){
         System.out.println(this+"...............");
         System.out.println(this.name+"您好,我是"+name);
     }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person+"...");
        person.name = "沉香";
        person.speak("刘彦昌");

        System.out.println("====================");

        Person person2 = new Person();
        System.out.println(person2+"......");
        person2.name = "王思聪";
        person2.speak("王健林");
    }
}

public class Person {
    private String name;
    private int age;

    //为name属性提供get/set方法

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}
public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.setName("萌姐");
        person1.setAge(48);
        System.out.println(person1.getName()+"..."+person1.getAge());

        System.out.println("=================================");

        Person person2 = new Person();
        person2.setName("涛哥");
        person2.setAge(18);
        System.out.println(person2.getName()+"..."+person2.getAge());
    }
}

3.构造方法

1.构造方法作用:主要是new对象的

2.特点:

a.方法名和类名一致
b.没有返回值,连void都没有

3.空参构造

1.格式:
  public 类名(){
      
  }

2.作用:
  new对象使用
      
3.注意:
  a.我们一new,就相当于调用了构造方法
  b.jvm会为每个类都提供一个空参构造,不写也有    
public class Person {
    private String name;
    private int age;

    //空参构造
    public Person(){
        System.out.println("我是空参构造");
    }

    //为name属性提供get/set方法

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
    }
}

构造方法可以是其他的权限修饰符,比如private修饰,如果被private修饰了构造方法,我们就不能利用构造方法new对象了

4.有参构造

1.格式:
  public 类名(形参){
      为属性赋值
  }

2.作用:
  a.创建对象
  b.为属性赋值
      
3.注意:
  如果写上了有参构造,jvm将不再提供无参构造了,所以建议都写上
public class Person {
    private String name;
    private int age;

    //空参构造
    public Person(){
        System.out.println("我是空参构造");
    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //为name属性提供get/set方法

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();

        System.out.println("==================");

        Person person2 = new Person("张无忌",25);
        System.out.println(person2.getName());
        System.out.println(person2.getAge());
    }
}

5.标准JavaBean

JavaBean是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：

  • 类必须是具体的(非抽象 abstract)和公共的，public class 类名
  • 并且具有无参数的构造方法
  • 成员变量私有化，并提供用来操作成员变量的set 和get 方法。
public class Person {
    private String name;
    private int age;

    //空参构造
    public Person(){
        System.out.println("我是空参构造");
    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //为name属性提供get/set方法

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
    private int id;
    private String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Test01 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        System.out.println(student.getId()+"..."+student.getName());

        System.out.println("=======================");
        Student student1 = new Student(2, "李四");
        System.out.println(student1.getId()+"..."+student1.getName());
    }
}

static关键字

1.static的介绍以及基本使用

1).概述: static静态关键字
2).使用:

a.修饰成员变量: static 数据类型 变量名
b.修饰方法:
修饰符 static 返回值类型 方法名(形参){
方法体
return 结果
}

3.static的特点:

a.静态成员属于类成员,静态成员会随着类的加载而加载
b.静态成员会优先于对象存在(非静态成员属于对象的成员)
c.凡是根据static所在的类创建出来的对象,都可以共享这个静态成员

4.调用:类名直接点
public class Student {
    int id;
    String name;
    static String classRoom;
}
public class Test01 {
    public static void main(String[] args) {
        //类名直接调用
        Student.classRoom = "教研室9";

        Student s1 = new Student();
        s1.id = 1;
        s1.name = "张三";
        s1.classRoom = "教研室90";
        System.out.println(s1.id);
        System.out.println(s1.name);
        System.out.println(s1.classRoom);

        System.out.println("================");

        Student s2 = new Student();
        s2.id = 2;
        s2.name = "李四";
        s2.classRoom = "教研室900";
        System.out.println(s2.id);
        System.out.println(s2.name);
        System.out.println(s2.classRoom);
        //System.out.println(s1.classRoom);
    }
}

2.static修饰成员的访问特点

1.在静态方法中能直接访问非静态成员嘛?不能
new对象访问

2.在静态方法中能直接访问静态成员嘛?能
a.在同一个类中 -> 直接调用
b.不在同一个类中 -> 类名调用

3.在非静态方法中能直接访问静态成员嘛?能
a.在同一个类中 -> 直接调用
b.不在同一个类中 -> 类名调用

4.在非静态方法中能直接访问非静态成员嘛?能
a.在同一个类中 -> 直接调用
b.不在同一个类中 -> new对象调用

总结:

1.调用静态的:不管在不在同一个类中,能直接调用就直接调用,不能直接调用类名调用

2.调用非静态的:不管在不在同一个类中,能直接调用就直接调用,不能直接调用就new对象调用

可变参数

1.介绍和基本使用

1).格式:
数据类型…变量名

2).本质:可变参数本质上是数组

3).注意:
参数位置只能有一个可变参数,而且要在参数列表最后

public class Demo01Var {
    public static void main(String[] args) {
        method(1,2,3,2,3,4,53,4,5);
        
        method02(1,2,3,4,5);
    }
    public static void method(int...arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("sum = " + sum);
    }
    
    public static void method02(int a,int...arr){
        
    }
}

2.可变参数

在JDK1.5之后，如果我们定义一个方法时，此时某个形参的类型可以确定，但是形参的个数不确定，那么我们可以使用可变参数。

格式:【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型… 形参名){ }

要求：

(1)一个方法最多只能有一个可变参数

(2)如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个

(3)其实这个书写“≈”

【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者更灵活，既可以传递数组，又可以直接传递数组的元素，这样更灵活了。

递归

1.概述:方法内部自己调用自己

2.分类:

a.直接递归: 方法内部自己调用自己
b.间接递归:
方法之间互相调用

3.注意:

a.递归必须要有出口,否则会出现”栈内存溢出”
b.即使有出口,也不要递归太多次,否则也会出现”栈内存溢出”

public class Demo01DiGui {
    public static void main(String[] args) {
        method();
    }

    public static void method() {
        method();//没有出口,就会出现栈内存溢出现象
    }
}

4.递归

  • 递归：指在当前方法内调用自己的这种现象。
  • 递归的分类:
    • 递归分为两种，直接递归和间接递归。
    • 直接递归称为方法自身调用自己。
    • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
  • 注意事项：
    • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出(因为会不断的压栈)。
    • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。

示例:利用递归输出3到1

public class Demo02DiGui {
    public static void main(String[] args) {
        method(3);
    }

    public static void method(int n) {
        if (n==1){
            System.out.println(n);
            return;//结束方法
        }
        System.out.println(n);
        n--;
        method(n);
    }
}

方法参数

1.基本数据类型做方法参数传递

基本类型做方法参数传递,传递的是变量的值,不是变量本身

public class Test01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        /*
           参数为基本类型,传递的是变量代表的值
           不是变量本身
         */
        method(a,b);
        System.out.println(a);//10
        System.out.println(b);//20
    }
    public static void method(int a,int b){
        a+=10;
        b+=20;
        System.out.println(a);//20
        System.out.println(b);//40
    }
}

2.引用数据类型做方法参数传递

引用类型做方法参数传递,传递的地址值

public class Test02 {
    public static void main(String[] args) {
        int[] arr = {10,20};
        method(arr);
        System.out.println(arr[0]);//20
        System.out.println(arr[1]);//40
    }
    public static void method(int[] arr){
        arr[0]+=10;
        arr[1]+=20;
        System.out.println(arr[0]);//20
        System.out.println(arr[1]);//40
    }
}

文末附加内容
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																					

							
							
						

										
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!