JAVA基础(5)

最新推荐文章于 2025-04-10 21:27:00 发布

原创最新推荐文章于 2025-04-10 21:27:00 发布 · 188 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

JAVA 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了Java面向对象编程的相关知识。阐述了面向对象思想可将复杂事情简化，还详细讲解了类的定义、成员变量与局部变量的区别、方法的实参与形参、重写和重载，以及构造方法、this和extends关键字、封装等内容，同时提及了static的使用。

面向过程：强调的是过程，所有事情都需要自己完成

面向对象：是一种更符合我们思想习惯的思想（懒人思想，自己的事情不做，交给别人做）可以将复杂的事情简化，将我们从执行者变成了指挥者，角色发生转换

1、定义：

首先把客户的需求抽象出业务逻辑对象

然后对需求进行分层

构建对应的独立的业务模块

之后进行设计业务逻辑，利用封装，继承，多态，抽象思想

实现实际业务需求

最后通过整合各个模块，达到高内聚，低耦合的效果，从而满足客户需求

class类

1、定义了一种抽象数据类型

类不但定义了抽象数据类型的组成（成员变量），同时还定义了可以对该类型实施的操作（方法）。

2、定义类的成员变量

类的定义包括“成员变量”的定义和“方法”的定义，其中“成员变量”用于描述该类型对象共同的数据结构

Java语言中，类的成员变量的定义可以使用如下语法

成员 变量类型 变量名称

........

3、成员的数据类型默认初始值

数值类型（byte、short、int long ） 0

boolean型 false

char型 /u0000

引用类型 null

4、类中除了定义成员变量，还可以定义方法，用于描述对象的行为，封装对象的功能

class类名{
修饰词  返回值类型  方法名称（参数列表）{

		方法体... ... ...

}

	... ... ...
}

成员变量和局部变量

1.在类中的位置不同：

成员变量：类中，方法外

局部变量：方法中或者方法的声明上（形参）

2.在内存中：

成员变量：堆内存中
局部变量：栈内存中

3.初始化:

成员变量：有默认值；
局部变量：没有默认值，必须是要先进行声明后进行初始化。

4.生命周期:

成员变量：随着对象的创建存在，对象消失而消失
局部变量：随着方法的调用存在，方法调用完毕后消失

public class VariableTest {
	//成员变量	
	static int x;
	
	public static void main(String[] args) {
		x = 66;
		printInfo();
		System.out.println(x);
	}
	public static void printInfo() {
		x = 76;
		int y = 5;
		System.out.println(x + "------");
		System.out.println(y);
	}
	
}

方法

实参与形参

基本数据类型

package CodeDemo05;

import javax.swing.plaf.basic.BasicInternalFrameTitlePane.IconifyAction;
//
/**
 * 如果方法的参数是基本数据类型，形参的改变不会影响实参的改变
 * 形参：用于接受实际参数的变量
 * 实参：实际参与运算的变量
 * 
 * 
 * */
public class ManthedTest01 {
	public static void main(String[] args) {
		/**实参*/
		int x = 10;
		int y = 5;
		System.out.println("x:"+x+"y:"+y);//x = 10,y = 5
		System.out.println("--------------");
		changeNumber(x,y);
		System.out.println("x:"+x+"y:"+y);
		System.out.println("==============");//x = 10,y = 5
	}
	public static void changeNumber(int x,int y){//形参
		y = x;
		y = x + y;
		System.out.println("x:"+x+"y:"+y);//x = 10,y = 20
		System.out.println("...........");
	} 
}

引用数据类型

package CodeDemo05;
/**
 * 如果方法的参数是引用数据类型，形参的改变会影响实参的改变
 * 形参：用于接受实际参数的变量
 * 实参：实际参与运算的变量
 * 
 * */
public class ManthedTest02 {
	public static void main(String[] args) {
		int[] age = {1,3,5,8};
		System.out.println("==============");
		for (int i = 0; i < age.length; i++) {
			System.out.println(age[i]);			
		}
		System.out.println("------------");
		changeNember(age);		
		for (int i = 0; i < age.length; i++) {
			System.out.println(age[i]);				
		}		
	}
public static void changeNember(int[] age){
	
	for (int i = 0; i < age.length; i++) {
		if (age[i] % 2 == 0) {
			age[i] *= 3;			
		}
		System.out.println(age[i]);			
	}
	System.out.println("。。。。。。。。。");
}
}

重写和重载

重载与重写是完全不同的语法现象,区别如下:
1、重载是指在一个类中定义多个方法名相同但参数列表不同的方法,在编译时,根据参数的个数和类型来决定绑定哪个方法。
2、重写是指在子类中定义和父类完全相同的方法,在程序运行时,根据对象的类型不同(而不是引|用类型)而调用不同的版本。

3、重载遵循所谓“编译期绑定”, 即在编译时根据参数变星的类型判断应该调用哪个方法;因为:变星obj的类型为Super ,因此Goo的g(Super)方法被调用。

4、重写遵循所谓“运行期绑定” ,即在运行的时候根据引用变量指向的实际对象类型调用方法;因为 obj实际指向的是子类的对象,因此: 子类重写后的f方法被调用。

package CodeDemo05;
/**
 * 求和的重载
 * 就近原则：char类型，转化为int类型
 * java中方法的调用参考两点，1>方法签名2>就近原则
 * System.out.println()也是重载
 * @author Administrator
 *
 */
public class AddDemo {

	public static void main(String[] args) {
	  adds ad = new adds();
	  System.out.println(ad.add('0',5));
 }
		
	
}

	class adds{
		public int  add(int x , int y ){
			System.out.println("1");
			return x + y ;
		}
		public int  add(int x ){
			System.out.println("2");
			return x + x ;

		}
		
		public double add(double x, double y ){
			System.out.println("3");
			return x+y;
		}
		public long  add(long x , long y ){
			System.out.println("4");
			return x + y ;
		}
	}

方法的签名

package CodeDemo05;
/**
 * 方法的签名：方法名+参数列表
 */
import org.omg.CORBA.PUBLIC_MEMBER;

public class OverLoadDemo {

	//现金的方式
	public void payByCash(double money){
		System.out.println("使用现金支付");
	}
	//信用卡的方式
	public void payByCard(String username, String password){
		System.out.println("使用信用卡支付");
	}
	//支票的形式
	public void payByCheck(double money, String name){
		System.out.println("使用支票支付");
	}
	//B方式：方法的重载：方法名相同，参数列表不同
	
	
	public void pay(double money){
		System.out.println("使用现金支付");
	}
	
	public void pay(String username , String password){
		System.out.println("使用信用卡支付");
	}
	
	public void pay (double money, String name){
		System.out.println("使用支票支付");
	}
	
}

构造方法

构造方法的语法格式:

构造方法时类中定义的方法，不同于其他的方法，构造方法的定义：

构造方法的名称必须与类名相同

构造方法没有返回值但也不能写void

[访问修饰词]类名（）{

//构造方法体

}

this关键字

this关键字用在方法体中,用于指向调用该方法的当前对象;简单的说:

哪个对象调用方法, this指的就是哪个对象。

严格来讲在方法中需要通过this关键字指明当前对象。例如:

  public void drop(){ 

  this.row++;

  为了方便起见，在没有歧义的情况下可以省略this :

  public void drop (){

  row ++;

}

extends关键字（继承）

1、继承：发现一些类中的属性和方法是相同的，所以把这些相同的属性和方法提取到一个新的类中，然后利用extends关键字让原来的类和新的类产生联系，这种联系称之为继承。

2、通过extends关键字可以实现类的继承;

1）子类(Sub class )可以继承父类( Super class )的成员变量及成员方法,同时也可以定义自己的成员变星和成员方法;
2）Java语言不支持多重继承,一个类只能继承一一个父类,但-一个父类可以有多个子类，Java是单继承

代码应用

package  CodeDemo05;
/**
 * 继承：
 * extends
 * @author Administrator
 *
 */
public class ExtendsDemo {

	public static void main(String[] args) {
		LOL l = new LOL("LOL", 111, "腾讯","PDD");
		l.printInfo();
		l.start();
		l.stop(); 
		
		Honor h = new Honor("王者荣耀", 121, "腾讯", false);
		h.printInfo();
		h.start();
		h.stop();
	}
	
}

class Game{
	String name;//名称
	int version;//版本号
	String agent;//代理商
	boolean isPC;//是否是PC端游戏
	
	/**构造方法-----给LOL--客户端提供构造方法*/
	public Game(String name, int version, String agent) {
		this.name = name;
		this.version = version;
		this.agent = agent;
	}
	
	/**给王者荣耀手游端的提供----构造*/
	public Game(String name, int version, String agent, boolean isPC) {
		this.name = name;
		this.version = version;
		this.agent = agent;
		this.isPC = isPC;
	}
	
	public void start() {
		System.out.println("游戏启动...");
	}
	
	public void stop() {
		System.out.println("游戏暂停...");
	}
	
	public void printInfo() {
		System.out.println(name + "," + version + "," + agent);
	}
}


class LOL extends Game{
	String player;//玩家
	
	public LOL(String name, int version, String agent, String player) {
		super(name, version, agent);
		this.player = player;
	}

	//重写
	@Override
	public void start() {
		System.out.println("游戏启动后先进行更新...");
		System.out.println("游戏玩家" + player + "登入成功。");
	}
	
}

class Honor extends Game{

	public Honor(String name, int version, String agent, boolean isPC) {
		super(name, version, agent, isPC);
	}
	
}

封装

对外提供可调用的、稳定的功能；

1、封装容易变化的、具体的实现细节、外界不可访问、这样的意义在于：降低代码出错的可能性、便于维护

2、当内部的实现细节改变时，只需保证对外的功能定义不变，其他的模块就不会因此而受到牵连。

/**

类是Java中最基本的组成单元，Java将描述一类事物的属性（状态）和功能（行为）封装在一起，属性用成员变量来刻画；功能通过方法来体现。简单来说，类是一个模板，它描述一类对象的行为和状态。那么有了这这个描述我们对类的的人是就已经可以了。下面我们来看一下类的模板：

public class Human{
  String name;
  int age;
  String skinColor;
  void barking(){
  }

  void hungry(){
  }

  void sleeping(){
  }
}

首先我们来看一下方法的结构：

方法的访问权限返回值方法名（参数）{

}
1.访问权限：public、protected、友好的和private，其中友好的默认为不加任何东西。
2.返回值：如果我们定义了void，证明我们所写的方法没有返回值。那么如果我们想让方法返回一个值（也就是返回值），3.那么这里就应该写你想返回回来的数据类型。
4.方法名：根据命名规则书写即可。

构造方法：

在这里必须要强调一下构造方法。上面给出的例子就是构造方法的。每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
特点：必须有，方法名与类名相同，没有返回值，不写时程序在编译时会自动生成一个返回值。

我们在看一段程序：

package com.zzxt.chx;

public class Human {
    String name;
    public Human(String name) {
        this.name=name;
    }
    public Human(){

    }
    void walk(){
        System.out.println(name+"散步");
    }
}

这里我们着重看一下构造方法中的this，这个this所指的就是Human.name

static:

1.可以修饰属性
2.可以修饰方法
3.可以单独使用

有static搜秀是的变量为静态变量，由ststic修饰的方法为静态方法，他们可以直接使用：类名.静态变量/类名.静态方法。
也就是想访问static所修饰的变量不需要经过实例化。
更为重要的一点，就是静态变量是类所特有的，如果实例化后被某一个对象所赋值，那么之后的对象在想访问后，他的值会变成之前被赋值的值。

我们看下面一段代码：

package com.zzxt.chx;

 class Main{
    public static void main(String[] args) {
        jingtaibianliang d=new jingtaibianliang();
        jingtaibianliang d2=new jingtaibianliang();
        System.out.println(d.num1="静态变量赋值");
        System.out.println(d.num2="非静态变量赋值");
        System.out.println(d2.num1);
        System.out.println(d2.num2);

    }
}
class jingtaibianliang {
    static String num1="静态变量初始值";
    String num2="非静态变量初始值";
}