JAVA开发学习-day03
1.方法
1.1 基本定义
Java中的方法是执行特定操作的代码块，它可以返回一个值或者不返回任何值。 方法由几个关键部分组成：
返回类型：指定方法执行后返回的数据类型。如果方法不返回任何值，则使用void关键字。
方法名：一个有效的标识符，用于标识方法。方法名应反映方法的功能。
参数列表：可选的，括号内包含要传递给方法的参数，参数之间用逗号分隔，每个参数必须有明确的类型和名称。
方法体：花括号内包含的代码块实现了方法的具体逻辑。
//方法 函数 过程
//语法
//返回值类型 方法名(参数列表){方法体} 参数列表与业务逻辑相关
//返回值类型 该方法必须返回这个类型的对象
//当一个方法不需要返回值 返回值类型定义为void
//void中不能return null
//void 可以写return
//求最大值
public static int max(int a, int b){
System.out.println();
return a > b ? a : b;
//return后不能写代码
}
//定义一个sum方法
public static int sum(int a, int b){
return a + b;
}
public static void printmax(int a, int b){
System.out.println(a > b ? a : b);
return; //终止方法作用
}
public static void printMaxA(int a, int b){
//求出最大值
//打印
printmax(a , b);
}
1.2 实参 形参
形参:方法定义时的参数,由数据类型和参数名组成
实参: 方法调用时用的参数
public class EasyA {
public static void main(String[] args) {
int a = sum(1, 2); //实参:调用方法时传入的参数,sum(1, 2)就是实参
}
}
//定义一个sum方法
//形参:定义方法时，参数列表的参数名 int a , int b就是形参
public static int sum(int a, int b){
return a + b;
}
1.3 重载
在同一个类中，方法名相同，参数列表不同即为重载
可以通过改变参数列表来实现重载
//参数列表要素
//1.参数类型不同
public static void printmax(byte a, int b){
}
//2.参数的个数不同
public static void printmax(short a){
}
//3.参数的顺序不同 参数中的类型顺序不同
public static void printmax(int b, byte a){
}
/*与返回类型无关
即方法定义时除了返回值类型都相同，是不可行的
public static int printmax(int b, byte a){
}*/
1.4 可变参数
1.一个方法中最多有一个可变参数
2.可变参数必须在参数列表的最后一个
3.可变参数数量可变，类型不可变
4.调用可变参数方法，可以使用数组代替
5.可变参数可以不传
public class EasyA {
public static void main(String[] args) {
int[] arr = {312,312,4342};
// int[] arr; arr = {1,2,3}; ❌
System.out.println(sum(1,2,4,54,5,3,4,345,34,52,45,245245,425,2,5));
sum(arr);
}
}
//可变参数 在数据类型后加...
//使用 将可变参数当作数组使用
//注意点:
//1.一个方法中最多有一个可变参数
//2.可变参数必须在参数列表的最后一个
//3.可变参数数量可变，类型不可变
//4.调用可变参数方法，可以使用数组代替
//5.可变参数可以不传
public static int sum(int... a){
int sum = 0;
for( int item : a ){
sum += item;
}
return sum;
}
1.5 在其他类中调用方法
在同一包下调用其他类的方法
//类名.方法名()
public class TestA {
public static void main(String[] args) {
//在其他类中调用EasyA类的方法
EasyA.printmax(12 , 23);
}
}
2.排序
2.1 冒泡排序
冒泡排序（Bubble Sort）是一种简单的排序算法，它通过多次遍历待排序的元素，比较相邻元素的大小，并交换它们直到整个序列有序。冒泡排序的基本思想是将较大的元素逐渐“浮”到数组的右端，而较小的元素逐渐“沉”到数组的左端。其基本原理如下：
1.从数组的第一个元素开始，比较相邻的两个元素。
2.如果前一个元素大于后一个元素（升序排序），则交换它们的位置。
3.步骤1和步骤2，直到遍历整个数组。
4.重复上步骤，每次遍历都将最大的元素“冒泡”到数组的末尾。
5.重复以上步骤，但不包括已排序的最大元素，直到整个数组排序完成。
import java.util.Arrays;
public class TestA {
public static void main(String[] args) {
int[] arr = {100,55,65,84,54,12,56,15,-1};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static int[] bubbleSort(int[] arr){
for(int i = 0 ; i < arr.length - 1; i++){
for(int j = 0 ; j < arr.length - 1 - i; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
}
3.类
编程时先定义好类，再对类实例化产生对象。类的形式如下：
class declaration{ //类声明部分
class body //类体部分
}
3.1 全局变量（在类中定义属性）
全局变量通常被定义为类的成员变量。全局变量可以在类的任何地方访问，而不限于特定的方法或代码块。
public class Staff {
//在类中定义属性
//又叫做全局变量:在整个类都可以访问到的变量
String code;
String sex;
String name;
// double slaray;
// 浮点数不能精确地表示十进制小数,可能导致精度损失和计算错误。
/*BigDecimal salary; 所以在涉及金钱时一般用BigDecimal*/
double salary;
//类中的方法可以直接调用本类中的属性
public void work(){
System.out.printf("%s正在工作\n", name);
}
}
3.2 构造方法
构造方法是用于创建和初始化对象的特殊方法。构造方法的正确编写和使用对于编写高质量的Java代码至关重要。
public class Staff {
//在类中定义属性
//又叫做全局变量:在整个类都可以访问到的变量
String code;
String sex;
String name;
// double slaray;
// 浮点数不能精确地表示十进制小数,可能导致精度损失和计算错误。
/*BigDecimal salary;*/
double salary;
//定义构造方法
//1.没有返回值类型
//2.方法名和类名一致
//3.如果一个类没有定义任何构造方法，系统会给与一个默认的空的构造方法
//4.类中一旦自定义了任意构造方法，系统给定的默认构造方法就消失了
//默认构造方法如下所示
Staff(){
}
//构造方法设置属性
Staff(String code, String name, String sex, double salary){
//将参数name设置给属性name
//就近原创 name = name; ----->两个都是参数name
//局部变量:在方法体或者代码块中声明的变量
//全局变量:在类当中定义的变量
//在局部变量和全局变量重名的情况下，可以使用this关键字，标注全局变量
this.code = code;
this.name = name;
this.sex = sex;
}
}
构造方法的访问修饰符通常是 public，以确保其他类可以访问并创建对象。
构造方法的名称必须与类名完全相同。
构造方法可以不带参数，称为无参数构造方法，也可以带有参数，称为带参数构造方法。
带参数的构造方法用于接收传递给构造方法的参数，并在对象初始化时使用这些参数来设置对象的属性。
3.3 实例化对象
public class TestStaff {
public static void main(String[] args) {
//实例化对象 开辟内存空间
Staff staff = new Staff();
//设置对象的属性 类中声明了哪些属性，对象中就有什么属性
staff.code = "YG10001";
staff.name = "张三";
staff.sex = "男";
staff.salary = 10000;
Staff staffA = new Staff();
staffA.code = "YG10002";
staffA.name = "李四";
staffA.sex = "女";
staffA.salary = 12000;
//使用构造方法初始化对象
Staff staffB = new Staff("YG10003","钱五","男",200);
}
}
4.面向对象特征（特性）
封装，继承，多态
4.1 封装
封装: 隐藏类当中的细节(属性，方法等)，不让其他类随意访问
通过四个访问权限修饰符来界定访问权限和范围以达到封装的效果
public protected default private
公共的 受保护的(家族性的) 默认(本包中) 私有的(本类中)
四个访问权限的修饰符界定的访问权限和范围如下图所示:
由于私有的(private)属性只能在本类中访问，所以外部类想要调用或修改私有属性就需要用到getter和setter方法
public class EasyC {
//面向对象特征(特性)
//封装 继承 多态
//封装 隐藏类当中的细节(属性，方法等)，不让其他类随意访问
//通过四个访问权限修饰符来界定访问权限和范围以达到封装的效果
// public protected default private
// 公共的 受保护的(家族性的) 默认(本包中) 私有的(本类中)
// 为了访问私有属性所以设置了getter，setter方法
// getter setter javabean(专门存储数据的java类)
public static int num_public = 22;
static int num_default = 33; // default
private String name;
private String code;
private String sex;
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getName(){
//java语言中大小写敏感
return this.name;
}
public void setName(String name){
this.name = name;
}
}
在IDEA可以在类的区域右键，选择Generate来快速生成getter和setter方法
4.2 继承
继承 一个类可以继承父类，子类就具有父类中定义好的属性和方法, 其关键字为extends
但不是所有的属性和方法都能访问到
可以继承的属性和方法前的权限修饰符: public, protected, 本包下的父类default
继承的好处:
1.代码重用
2.多态实现的基础
注意:
1.java中一个类只能有一个直接父类（单继承）
2.java支持多重继承
4.2.1 方法的重写
子类可以对父类中的方法进行重写，重写的方法只有方法体不同，其余要与父类的方法一致
可以使用@Override注解，验证方法是否是重写的方法
重写的方法的访问权限只能更开放，不能更闭塞 protected -> public √ public -> private ❌
class Plane{
protected String code; //protected 可以被子类或子代关系类 或本包下的类可以访问
String color;
public void fly(){
System.out.println("起飞！！！");
}
}
//用关键字extends继承类
class BigPlane extends Plane{
public String code;
//子类继承父类
//方法的重写:子类对父类中继承过来的方法重新定义
//重写只能改写方法体，其余不能改变
//可以使用@Override注解，验证方法是否是重写的方法
//重写的方法的访问权限只能更开放，不能更闭塞 protected -> public √ public -> private ❌
@Override //对父类中的fly()进行了重写
public void fly(){
System.out.println("超级起飞！！！！");
}
}
4.2.2 子父类之间的构造方法
子类的构造方法中首行必须要用父类的构造方法
默认调用父类的无参构造方法
class Plane{
protected String code; //protected 可以被子类或子代关系类 或本包下的类可以访问
String color;
}
//用关键字extends继承类
class BigPlane extends Plane{
//此时父类中没有构造类，所以子类调用的父类的默认无参构造方法
//如果父类中的构造方法是无参的，子类不写构造类也可
}
父类当中没有无参构造方法，子类构造方法必须定义调用父类的哪一个构造方法
使用supper关键字调用父类的构造方法
class Plane{
protected String code; //protected 可以被子类或子代关系类 或本包下的类可以访问
String color;
public Plane(String code) {
this.code = code;
}
public Plane(String code, String color){
this.code = code;
this.color = color;
}
public Plane(){
}
}
//用关键字extends继承类
class BigPlane extends Plane{
public String code; //子类中的属性可以和父类中的一致
//子父类间的构造方法
public BigPlane(String code, String color){
//子类的构造方法中首行必须要用父类的构造方法
//默认调用父类的无参构造方法
//父类当中没有无参构造方法，子类构造方法必须定义调用父类的哪一个构造方法
//使用supper关键字调用父类的构造方法
//super();
super(code,color);
}
public BigPlane(String code){
super(code);
}
public BigPlane(){
super();
}
}
只要在子类构造方法的方法体首行调用了父类的supper()方法就不会报错
class Plane{
protected String code; //protected 可以被子类或子代关系类 或本包下的类可以访问
String color;
public Plane(String code, String color){
this.code = code;
this.color = color;
}
public Plane(){
}
}
//用关键字extends继承类
class BigPlane extends Plane{
public String code;
public BigPlane(String code, String color){
super(); //调用父类无参的构造方法
}
}
4.2.3 向上转型
Java 的向上转型是一种多态的实现方式，它允许我们使用父类类型的引用变量来引用子类类型的对象，并且可以通过这个引用变量调用子类中重写或继承自父类的方法。向上转型的作用主要体现在两个方面：增强代码的灵活性和可扩展性，以及强制规范类的结构和行为。
public class HomeWork {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
//调用了子类中重写的move方法
animal1.move(); //输出为狗在移动
//子类中没有重写sleep方法，所以调用的子类继承父类的方法sleep
animal2.sleep(); //输出为动物在睡觉
//animal1.bark(); // 编译错误，Animal类型不能调用Dog类型的方法
//向上转型的父类类型变量可以引用子类对象，但只能调用子类中重写或继承自父类的方法，不能直接访问子类中特有的方法。
}
}
class Animal {
public void move() {
System.out.println("动物在移动");
}
public void sleep() {
System.out.println("动物正在睡觉");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("狗在嗷嗷叫");
}
public void move() {
System.out.println("狗在移动");
}
}
class Cat extends Animal {
public void scratch() {
System.out.println("猫在挠人");
}
}
4.2.4 调用属性看变量声明
public class EasyD {
public static void main(String[] args) {
//调用属性看变量的声明
BigPlane bigPlane = new BigPlane();
bigPlane.code = "AAAA";
bigPlane.printcode();
//变量声明为 BigPlane，所以子类的code变为"AAAA"
//输出结果为 this.code:AAAA super.code:null
Plane plane = new BigPlane();
plane.code = "BBBB";
plane.printcode();
//变量声明为 Plane，所以父类的code变为"BBBB"
//输出结果为 this.code:null super.code:BBBB
BigPlane plane1 = (BigPlane) plane;
plane1.code = "CCCC";
plane1.printcode
//变量声明为 BigPlane，所以子类的code变为"CCCC"
//输出结果为 this.code:CCCC super.code:BBBB
}
}
class Plane{
protected String code; //父类的code
String color;
public Plane(String code) {
this.code = code;
}
public Plane(String code, String color){
this.code = code;
this.color = color;
}
public Plane(){
}
public void fly(){
System.out.println("起飞！！！");
}
public void printcode(){
System.out.println(code);
}
}
//用关键字extends继承类
class BigPlane extends Plane(
public String code; //子类的code
public BigPlane(String code, String color){
super(code,color);
}
public BigPlane(String code){
super(code);
}
public BigPlane(){
super();
}
@Override
public void printcode(){
System.out.println("this.code:" + this.code);
System.out.println("super.code:" + super.code);
}
}
4.3 多态
多态是面向对象编程中的一个重要概念,它允许不同类型的对象对同一方法进行不同的实现。
public class EasyE {
//简单工厂设计模式
public static Parent getObj(int a){
if(a == 1){
return new ChildA();
}else if(a == 2){
return new ChildB();
}else {
return new Parent();
}
}
public static void main(String[] args) {
int num = 1;
Parent p = getObj(num); //p这个变量可能指向任意个子类的对象
p.method(); //多态: 调用方法时出现多种结果
//多态分类:
//静态多态: 重载造成，在类编译时，就可以确定调用的是哪一个方法
//动态多态: 重写造成，只有在执行过程中，才能确定执行的是哪一个类中的方法
}
}
class Parent{
public void method(){
System.out.println("parent");
}
}
class ChildA extends Parent{
@Override
public void method(){
System.out.println("ChildA");
}
}
class ChildB extends Parent{
@Override
public void method(){
System.out.println("ChildB");
}
}
162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
