Java方法与对象详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45716494/article/details/103407840

方法

一、格式：

访问控制 [static] 返回值 方法名(参数列表(若干个)){
    方法体;
}

参数是方法的入口，返回值是方法的出口
方法体：是由java最基础的组成部分拼接而成的

二、面向对象：

三、基本概念：

对象：万事万物皆对象，对象在不同场景下所表现出的特征是不一样的。一个对象应该由自己的属性和方法组成，但当很多个对象中具有相同的属性和方法时，我们就可以将其抽象成类。很多个对象中具有相同的属性和方法时，我们就可以将其抽象为方法和类。对象的返回值可以为null，但是int等数值型的返回值只能为数值。对象数据类型的初始值是null；
模板：由对象抽象出来的就是类模板；
抽象：将一个对象的特征和行为提取出来，从类创建对象；
类：相似对象的集合（一个类可以使用所属包中的所有类，以及其他包中的公有类）/ 所有的对象通过抽象的过程提取出来的框架就叫做类；

public class Person{ }

模版类：Object
全类名
简写类名

属性：根据对象决定属性的值，可以直接给出明确的值，属性一定是名词，名词不一定是属性。静态属性的一个特点是，所有的在该类下的对象，共享这个属性；

(1) 动态变量：简称变量，数值型变量的默认值为0、布尔型变量默认值为false、引用类型变量将设置为null
(2) 静态变量（类变量）:

独立于方法、构造方法或者语句块之外
用static修饰，存储在静态存储区，经常被声明为常量使用
静态变量属于类，在第一次被访问时创建，程序结束时销毁
具有默认值，可以在声明或构造方法中赋值，还可以在静态语句块中初始化

(3) 实例变量：

独立于方法、构造方法或者语句块之外
使用实例变量前后都可以声明
可以用访问修饰符修饰，一般设置为私有
实例变量属于对象，当对象被实例化后，实例变量也就确定了
具有默认值，可以在声明或构造方法中赋值
可以通过变量名访问

(4) 局部变量 / 临时变量：

声明在方法、构造方法或者语句块中，且只在它们之内可见
在方法、构造方法或者语句块被执行时创建，执行完毕后被销毁
不可用访问修饰符修饰
没有默认值，不赋初值不可使用
声明之后必须初始化才能使用
(5)成员变量：
不赋初值可以使用
基础数据类型的成员变量都是有默认值的

public class Person {
    int eyes = 2;    //成员变量
    public static void main(String[] args){
        int age = 20;    //局部变量
    }
}

方法参数的类型：基本数据类型、对象引用。方法参数的使用情况：一个方法不能修改一个基本数据类型的参数、一个方法可以改变一个对象参数的状态、一个方法不能让对象参数引用一个新的对象。

(1) 两种参数类型：

实参：调用方法时传递给方法的参数，传递之前必须赋值
形参：定义方法时使用的参数，用于接收调用时所传递的参数。只在使用时被分配存储单元，使用后被销毁，所以只在方法内部有效

(2) 两种传参方式：

传值：内部操作对参数值没有影响
传址：内部操作是对参数指向的内存进行操作，对参数值有影响

条件：方法参数集合，定义时可以不赋值

String name;
int age;
double higth;
Person mate;

行为：一般来说描述对象时出现的动词就叫行为，很多个对象都有这个行为，那么他就是一个类级，一系列动作（操作）的集合，没有确定的值；
方法：（方法名、返回值类型、方法体、参数）一系列动作的集合，一定会得到一个结果，若规定了返回值类型，则必须return一个返回值（可以为空）。可以访问所调用对象的私有数据，一个方法可以访问所属类的所有对象的私有数据。按值调用，方法得到的是所有参数值的拷贝，不可修改传递给它的任何参数变量的内容。一个方法的开始条件是参数，结束条件是返回值

静态方法：没有对象就可以直接调用
动态方法：必须要有对象才能进行调用，“标志符.”
有参有返回值的方法

int MonthlySalary(int DailyWage){
    int salary = DailyWage * 30;
    return salary;
}

无参有返回值的方法

int earnMoney(){
   	int a = 3;
   	int b = 5;
   	return 13;         //return a-b
}

有参无返回值的方法

void eat(String foodtype,int price){
   	System.out.println(name + " is eating");
}

无参无返回值的方法

void run(){
    System.out.println("Is running");
}

任何方法都可以使用return，意味着无返回值的方法也可以使用return，return就是结束，代表着之后的内容不再执行。

封装（数据隐藏）：数据打包访问控制。把原来散列在各个对象里面的属性提取出来打成一个包，变成一个整体，提高重用性和可靠性（数据和行为组合在一个包中，并对数据的数据的使用者隐藏了数据的实现方式）；
对象中的数据称为实例域，操纵数据的过程称为方法；
实例化：用类的模板创建对象，new Person( ) 为了声明要创建多大的内存空间，即从类的模板把他变成一个真正存在的东西
由类构造对象的过程称为创建类的实例；
构造方法：一般是用来初始化，名字必须和类名一致，未定义是系统默认生成一个空的构造方法，自定义构造方法会覆盖系统默认的构造方法，无返回值，创建对象时一定会调用，只能在实例化的时候调用。普通方法：在特定场景下调用

//系统默认构造方法
Person(){
}

如果一个类具有某个动作那么通过这个类创建的对象都具有这个动作
new 创建新的对象，开辟新的内存，和原来的对象没有关系了，是对原来内存一个整体的替换。替换时是由等于号进行替换的，不是new
无返回值的对象也可以加return
Java的默认管理方式是包管理
this 表示隐式参数
普通的方法及属性必须动态的调用

构造器

特点：

构造器与类同名（首字母大写）；
每个类可以有一个以上的构造器；
构造器可以有0个、1个或多个参数；
构造器没有返回值；
未定义构造方法时，java默认给一个空构造方法，定义后自动将默认的构造方法删除；
构造器总是伴随着new操作一起调用（创建新对象时一定会调用构造方法）。

访问控制符

访问控制符（能见度）：可以修饰类、方法、属性

public：公有。在任意其他类当中的任意位置都可以访问或者调用被public修饰的属性或方法
private：私有。只能在本类中访问或者调用的属性或方法
protected：保护。包内和子类可访问
default：默认。包内可访问

class Super {
    private void print(){
        System.out.println("A");
    }
    public void foo(){
        this.print();
    }
}
class Sub extends Super {
    public void print() {
        System.out.println("B");
    }
}
public class main(){
    public class void main(String[] args){
        new Sub().foo();
    }
}

这段代码所打印出的结果为A，可以说明父类Super的私有方法print并没有被子类Sub继承，所以我认为私有方法并不能被继承。

修饰符

package：当没有加任何访问修饰符时，java默认的会加上一个访问控制符package，同包下可以访问，即友元访问过程（友元是C++的概念）
final：final实例域（公有常量），构建对象时必须初始化这样的域，大都应用与基本类型域，或不可变类的域
static：修饰属性、方法、内部类、代码块，static代码块加载类的时候就被执行了。被该关键字修饰的方法是静态方法，静态方法没有对象时也可以调用，动态方法没有对象时不可以调用修饰属性、方法、内部类（内部类可以写很多public class）

每个类中只有一个静态域，它属于类，而不属于任何独立的对象，在绝大多数的面向对象程序设计语言中，静态域被称为类域，静态方法是一种不能向对象实施操作的方法，静态方法可以访问自身类中的静态域

使用静态方法的情况：

一个方法不需要访问对象状态，其所需的参数都是通过显式参数提供例如Math.pow
一个方法只需要访问类的静态域

main方法也是静态方法，不对任何对象进行操作，启动时执行并创建程序所需要的对象，每个类可以有一个mian方法

单立模式将构造方法私有化

子类对象调用父类静态代码块时，子类的静态代码块不进入内存中间？（看22号录）

Java对象和内存之间的关系：

Java内存：程序计数器（记录代码执行到了第几行）、栈（对于对象的地址引用）（每个线程一个）、堆（所有的线程公用一个）（保存对象的真正位置的是堆，栈里保存的是堆里面的地址）、常量池、方法区
内存的物理地址：
在常量池中出现的数据不会在创建第二次，常量池中数据可以用 “==”进行比较，不是常量池中的数据不可以用“==” 进行比较
塌缩成基础数据类型就直接比较值（但是只有int integer）
== 比较地址。常量池中的内容可以进行比较
equals（）按照字面量进行比较

基础数据类型的对象类型

对象类型	基础数据类型	备注
Integer	int
Byte	byte
Short	short
Long	long
Float	float	浮点型精度不确定，所以用==比较时不相等
Double	double	同上
Character	char
Boolean	boolean

//转换方法 character没有
int a = Integer.parseInt(" ");

String st = "a";
st.charAt(0);

//a==b得到的结果是false，integer的128以下（不包括128）才是相等的，以上的指向了不同的地址
integer a = 133;
integer b = 133;

.compare(1,2);  //比较
.bitCount(3); //占的位数
.decode("0x05"); //使用这个方法，Integer可以转为int值
.max 
.min
.reverse(123); //倒过来
//最大值最小值
.MAX_VALUE
.MIN_VALUE

NaN是计算错误的情况0/0，infinity是无限3.0/0/0，NaN参与任何数值计算结果都是NaN，NaN!=NaN，infinity/infinity=NaN

字符串

String：

定义后内容不可变；
使用赋值运算符 “=”，内存一定被改变了；
replace：新生成内存空间，原字符串不会变；
split：分割字符串，结果为数组；
String是一个字符的容器，既然是一个容器，它一定符合容器的常用操作，求长、定位、替换。（字符串与数组的定位、求长、替换有什么区别？）
字符的替换不能在原地址上做、数组的替换在原地址上做，数组是连续的内存空间不能改变
添加、改变字符串中数据后，原数组不变、生成的是一个新数组

String的两种创建对象方式：

String str1 = "abc";      //只在常量池里创建了一个对象
String str2 = new String("abc");    //既在常量池里创建了一个对象，又在堆里创建了一个对象
//以上都不讨论栈 对象，算上栈分别是2个对象和3个对象

new与=号的区别：new 是开辟内存的，=是改变内存的

字符串的常用操作：

定位：charAt（1） indexOf（“a”）lastindexOf（“a”）lastindexOf（“a”，3）

求长：length()

替换：replace()、replaceAll()

拼接：concat(“a”) +号效率很低，尽量不要使用

包含：contains(“a”)

以…为开始：startsWith(“a”)

大写小写：toUpperCase()、toLowerCase()

不管大小写的等于判断：equalsIgnoreCase(str)

改变编码格式：String str = new String(arrays,“GBK”);

next与nextline的区别：

next()：读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。
nextLine()：结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。

永久代（static存在里面）（old） – 元数据区（now）

静不可调动、动可以调静，静可以调静

链式继承 - - 单继承 - - 类范畴的继承一个子类只能继承一个父类

里氏替换原则（LIS）：所有父类可以完成的工作子类都可以完成

多态

A extends B