Java_类和方法笔记

Posted 2021-09-06 过往将来

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java_类和方法笔记相关的知识，希望对你有一定的参考价值。

Java_面向过程(POP) 与面向对象(OOP)

面向过程编程，强调的是功能行为，以函数为最小单位，考虑怎么做。
面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等
面向对象的三大特征:封装 (Encapsulation),继承 (Inheritance),多态 (Polymorphism)

Java_面向对象分析方法分析问题的思路和步骤

根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念的类。
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

Java_类和对象

类(Class)和对象(Object)是面向对象的核心概念。
类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
注意:牢记一点:万事万物皆对象

Java_类对象

属性：对应类中的成员变量
行为：对应类中的成员方法

Java_类的语法格式

	public class Person{
		private int age ; //声明私有变量 age
			public void showAge(int i) { //声明方法showAge( )
			age = i;
		}
	}

Java_对象

java类的实例化，即创建类的对象
创建对象语法：类名对象名 = new 类名();
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

public class Zoo{
	public static void main(String args[]){
		//创建对象
		Animal xb=new Animal();
		xb.legs=4;//访问属性
		System.out.println(xb.legs);
		xb.eat();//访问方法
		xb.move();//访问方法
	}
}

注意重点:如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

public class Zoo {
	public static void main(String args[]) {
		Animal xb = new Animal();
		Animal xh = new Animal();
		xb.legs = 4;
		xh.legs = 0;
		System.out.println(xb.legs); // 4
		System.out.println(xh.legs); // 0
		xb.legs = 2;
		System.out.println(xb.legs); // 2
		System.out.println(xh.legs); // 0
	}
}

Java_类的访问机制

在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。
（例外：static方法访问非static，编译不通过。）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中
定义的成员。

Java_堆和栈详解

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。
Java虚拟机规范中的描述是：所有对象实例以及数组都要在堆上分配。
栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。
局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

Java_匿名对象

对不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。 例如:new Person().shout();
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。

Java_类的属性

语法格式修饰符数据类型属性名 = 初始化值 ;
常用的权限修饰符有：private、protected、public
其他修饰符：static
数据类型:任何基本数据类型(如int、Boolean) 或任何引用数据类型。
属性名:属于标识符，符合命名规则和规范即可

样例如下

public class Person{
	private int age; //声明private变量 age
	public String name = “Lila”; //声明public变量 name
}

Java_变量详解

在编程语言中,数据是存储在内存中的,变量就是对内存中数据的引用
变量的分类：成员变量与局部变量
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。

Java_成员变量和局部变量区别

成员变量是直接声明在类中的,修饰符有 private、public、static,final等,有默认初始化值,在内存中的堆空间中
局部变量是声明在方法形参或内部、代码块内、构造器内等,不能用权限修饰符修饰，可以用final修饰,没有默认初始化值,必须显式赋值后才能使用,数据存储在内存中调度栈空间中

Java_类成员-属性

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，

Java_类成员-方法

**什么是方法(method、函数)😗*方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
将功能封装为方法是为了是代码重用,简化代码
Java中,方法不能独立存在,所有方法都必须定义在类中

public class Person{
	private int age;
		public int getAge() { //声明方法getAge()
		return age;
	}
	public void setAge(int i) { //声明方法setAge
		age = i; //将参数i的值赋给类的成员变量age
	}
}

修饰符：public,private, protected等

返回值类型:

没有返回值:void
有返回值，声明出返回值的类型(例如int)。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。

**方法的调用:**方法通过方法名调用,且方法只有被调用才会执行

Java_方法的使用注意

方法被调用一次,就会执行一次
在没有具体返回值的情况,返回值类型用关键字void表示,那么方法体中可以不必使用return,如果使用return,仅用来结束方法
定义方法时,方法的结果应该返回给调用者,交由调用者处理
方法中只能调用方法或属性,不可以在方法内部定义方法

Java_方法的重载

重载的概念:在同一个类中,允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的特点:与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

重载方法的实例

package com.company;
public class PrintStream {
	public static void print(int i) {
		
	}
	public static void print(float f) {……}
	public static void print(String s) {……}
	public static void main(String[] args) {
		print(3);
		print(1.2f);
		print("hello!");
	}
}

Java_可变个数的形参简介

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。
从而，可以用一种更简单的方式，来传递个数可变的实参。这就简化了重载的使用
在JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量：public static void test(int a ,String[] books);
在JDK5.0以后：采用可变个数形参来定义方法，传入多个同一类型变量：public static void test(int a ,String…books);

Java_可变个数形参注意

声明格式：方法名(参数的类型名 ...参数名)
可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
可变个数形参的方法与同名的方法之间，彼此构成重载
可变参数方法的使用与方法参数部分使用数组是一致的
方法的参数部分有可变形参，需要放在形参声明的最后
在一个方法的形参位置，最多只能声明一个可变个数形参

package com.company;

public class Change_test {
    public void test(String[] msg){
        System.out.println("含字符串数组参数的test方法 ");
    }
    public void test1(String book){
        System.out.println("****与可变形参方法构成重载的test1方法****");
    }
    public void test1(String ... books){
        System.out.println("****形参长度可变的test1方法****");
    }
    public static void main(String[] args){
        Change_test te = new Change_test();
        //下面两次调用将执行第二个test方法
        te.test1();
        te.test1("aa" , "bb");
        //下面将执行第一个test方法
        te.test(new String[]{"aa"});
    }
}

Java_方法参数的值传递机制

方法必须由其所在类或对象调用才有意义。
若方法含有参数：形参：方法声明时的参数，实参：方法调用时实际传给形参的参数值

Java的实参值传入方法：

Java里方法的参数传递方式只有一种：值传递，即将实际参数值的副本
（复制品）传入方法内，而参数本身不受影响。
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

Java_基本数据类型参数传递样例

	package com.company;
	
	public class Join_parma_01 {
	//    基本数据类型的参数传递
	    public static void main(String[] args) {
	
	        int x = 5;
	        System.out.println("修改之前x = " + x);// 5
	        // x是实参
	        change(x);
	        System.out.println("修改之后x = " + x);// 5
	    }
	    public static void change(int x) {
	        System.out.println("change:修改之前x = " + x);// 5
	        x = 3;
	        System.out.println("change:修改之后x = " + x); // 3
	    }
	}

运行结果如下：

Java_引用数据类型传递样例

package com.company;

public class Join_parma_02 {
    public static class Person{
        int age;
    }
    public static void main(String[] args) {

        Person obj = new Person();
        obj.age = 5;
        System.out.println("修改之前age = " + obj.age);// 5
// x是实参
        change(obj);
        System.out.println("修改之后age = " + obj.age);// 3
    }
    public static void change(Person obj) {

        System.out.println("change:修改之前age = " + obj.age); // 5
        obj.age = 3;
        System.out.println("change:修改之后age = " + obj.age); // 3
    }
}

运行结果如下：

Java_将对象作为参数传递给方法

package com.company;

public class join_parma_03 {
    public static void main(String[] args){
        Num n1 = new Num();
        Num n2 = n1; // n1和n2引用同一对象，即它们有相同的引用值
        n1.i = 0;
        int x = 10;
        System.out.println("调用方法method1前：n1.i = "+n1.i+"\\tn2.i = "+n2.i+"\\tx = "+x);
        method1(n1,x);
        System.out.println("调用方法method1后：n1.i = "+n1.i+"\\tx = "+x);
        System.out.println((n1 == n2) ? "n1和n2引用同一对象" : "n1和n2引用不同对象");
        method2(n2);
        System.out.println("调用method2后：n1.i = "+n1.i+"        n2.i = "+n2.i);
        System.out.println((n1 == n2) ? "n1和n2引用同一对象" : "n1和n2引用不同对象");

    }
    static void method1(Num num,int y){
        num.i += y;
        y --;
        System.out.println("在退出method方法时：num.i = "+num.i+"\\ty = "+y);
    }
    static void method2(Num num){
        num = new Num();
        num.i += 100;
        System.out.println("退出method方法时: num.i = "+num.i);
    }
   public static class Num{
        int i;
    }
}

运行结果

首先创建 class Num 的对象 n1,并创建 Num n2 = n1，所以n1和n2有着相同的引用值，n1,n2都引用同一对象
对于method1方法来说，将n1的·值传递给了形参num，与n2和n1一样
在method1方法中对象num成员内容的任何改动，都会引起n1的内容改动。同时n1的变动也会引起n2的变动。
但是x传给y是值传递，所以y的变化则不会引起x的变化
对于method2来说，在它的函数体内重新申请了num的引用值，所以说对象num’的内容变动就不会再引起n2中内容的变化。

Java_递归方法

递归方法：一个方法体内调用它自身
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执
行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死
循环。

package com.company;

public class Java_DiGui_test {
    public static void main(String[] args) {
        Java_DiGui_test J = new Java_DiGui_test();
        System.out.println(J.sum(10));
    }
    public int sum(int num){
        if(num == 1){
            return 1;
        }else{
            return num + sum(num - 1);
        }
    }
}