java基础知识

文章目录

• java基础知识
• 七、类和对象
• • 7.1.对象
  • 7.2.类
  • • 7.2.1.概念
    • 7.2.2.成员变量
    • 7.2.3.成员方法
    • 7.2.4.局部变量
    • 7.2.5.this关键字
  • 7.3.面向对象的编程
  • 7.4.构造方法
  • • 7.4.1.私有构造方法
  • 7.5.静态修饰符static
  • • 7.5.1.静态变量
    • 7.5.2.静态常量
    • 7.5.3.静态方法
    • 7.5.4.静态代码块
    • 7.5.5.类的主方法
  • 7.6.对象的特性

七、类和对象

7.1.对象

• 背景：开发初期的程序语言采用结构化，随着时代发展，结构化使程序周期无限延长已不再适用

• 概念：我们这里介绍的对象，是一个抽象概念，英文叫Object，表示任意存在的事物。可不是单指俗话中的“对象”!，简单点说：世间万物

• 分类：

  • 静态：不能动的部分，称为属性，任何对象都会具备自身的属性，如一个人的高矮胖瘦，性别，年龄
  • 动态：
  • 

• 面向对象程序设计的思想要以对象来思考问题，首先要将现实世界的实体抽象为对象，然后考虑这个对象具备的属性和行为。

  例如：

  现在面临一只大雁要从北方飞往南方这样一个实际问题，试着以面向对象的思想来解决这一实际问题。

• 首先可以从这一问题中抽象出对象，这里抽象出的对象为大雁。
• 识别这个对象的属性。对象具备的属性都是静态属性，如大雁有一对翅膀、黑色的羽毛等。
• 识别这个对象的动态行为，即这只大雁可以进行的动作，如飞行、觅食等，这些行为都是因为这个对象基于其属性而具有的动作。
• 识别出这些对象的属性和行为后，这个对象就被定义完成，然后可以根据这只大雁具有的特性制定这只大雁要从北方飞向南方的具体方案以解决问题。

7.2.类

7.2.1.概念

• 概念：对一些事务具有相同的特点的统称，封装对象的属性和行为的载体

• 比如将具有以下属性和行为的事务划归为鸟类

7.2.2.成员变量

• java中类的属性，未设置值，则会使用默认的值，整型是0，字符是null
• 概念：在类体中定义的变量，也就是类的的{}定义的量
• 

7.2.3.成员方法

• java中的行为

• 

• 分类：

  • 有返回值：方法体中使用return进行结束标识，return 后面写上要返回的东西，返回的东西类型要与方法设置的类型一致
  • 无返回值：使用void进行标识

7.2.4.局部变量

• 概念：在方法中定义的变量

• 

package 第七章_类和对象;

public class T1创建局部变量 {
	String name;
    //成员变量name不进行初始化，也不会报错,会使用默认的值，所以结果为null
	public void getName() {
        //自定义的一个成员方法（getName）
		int id=10;
		System.out.println(id+name);
        //成员方法中定义的“局部变量id”未进行初始化
		
	}
//到main（）方法中测试一下，自定义的成员方法和局部变量
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
     	T1创建局部变量 test=new T1创建局部变量();
        //创建类的对象，与类名要一致，test随意
		test.getName();
        //test去调用创建的成员方法
		
	}

}

• 有效范围

• 
• 

• 在两个独立的方法中，变量重名了，也不影响，变量地址不同、方法执行时变量生效，方法结束后，变量立刻被销毁

• 

7.2.5.this关键字

• 当成员变量与局部变量重名时，成员变量会被掩盖，输出以局部变量为准

  package 第七章_类和对象;
  
  public class T2this关键字 {
  	String name="abc";
      //定义一个成员变量
  	public void showName(String name) {
  	//自定义一个成员方法，返回参数name	
  		System.out.println(name);
  	}
  
  	public static void main(String[] args) {
  		// TODO 自动生成的方法存根
  		T2this关键字 book =new T2this关键字();
  	//类名 新变量名=new 类名();
  		book.showName("123");
          //新变量.自定义的方法
  	}
  
  }
  
  

• 解决重名时成员变量被掩盖问题，使用this关键字

• 在java的类中，this代表特指类中的对象、属性

package 第七章_类和对象;

public class T2this关键字 {
	 String name="abc";
    //定义一个实例成员变量
	public void showName(String name) {
	//自定义一个含参数成员方法，返回参数name	
		System.out.println(name);
		System.out.println(this.name);
  //this.变量名  使用类中定义的变量，输出的应该是成员变量name="abc"

	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		T2this关键字 book =new T2this关键字();
	//类名 新变量名=new 类名();，因为我们创建的不是静态成员方法，必须类的实例化后才可以调用
		book.showName("123");
        //新变量.自定义的方法,将123作为showName成员方法的参数，返回去
		//System.out.println(name);报错，String name实例变量不能引用，
		//static String name (静态变量)均可以引用了
			
	}

}

• 权限修饰符
• 

特点:本包本类-----夲包异类-------所有包和类

类的权限会约束成员方法、变量的权限，例如类权限为private,即便方法权限为public,该方法也仅限于本类使用

7.3.面向对象的编程

• 封装
  • 概念：封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。
  • 黑盒测试：注重输入输出，不管过程

• 继承

  

• 多态

• 

在多态机制中，比抽象类更方便的是将抽象类定义为接口，而抽象方法组成的集合就是接口

7.4.构造方法

• 概念：构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

• 构造方法是一个与类同名的方法,也就是说，在一个类中，构造方法的名字不是你想怎么来就怎么来，这也是和成员方法的不同之处，成员方法的名字你爱怎么来就怎么来，什么啊猫啊狗的名字都可以😄

• 注意：

  • 构造方法也分有返回值和没有返回值两种

  • 在定义构造方法时，构造方法没有返回值，但这与普通没有返回值的方法不同，普通没有返回值的方法使用public void methodEx()这种形式进行定义，但构造方法并不需要使用void关键字进行修饰。构造方法不存在void

  • 在构造方法中可以为成员变量赋值，这样当实例化一个本类的对象时，相应的成员变量也将被初始化。

  • 如果类中没有明确定义构造方法，则编译器会自动创建一个不带参数的默认构造方法。

• 

• 

• 

理解

若自己自定义了构造方法（有参数），编译器均不会在自动创建一个不带参数的构造方法

若想要正常使用，则必须自己人为创建（与类实例化相对应的）构造方法

• 
• 实例化本类对象时，没有写参数，或者参数与构造方法类型不符

• 对象的初始化

  package 第七章_类和对象;
  
  public class T3构造方法 {
  
  	public static void main(String[] args) {
  		// TODO 自动生成的方法存根
  		T3构造方法 a= new T3构造方法();
          //直接使用，不会报错
  		//因为编译器自动创建了一个不带参数的构造方法，只能自动创建无参数的构造方法
  		/*public T3构造方法（）{
  		 
  		 }		 
  		 */
  
  	}
  
  }
  
  

  package 第七章_类和对象;
  
  public class T4构造方法a {
  	public T4构造方法a(int i) {
  		
  	}
  
  	public static void main(String[] args) {
  		// TODO 自动生成的方法存根
  		T4构造方法a b=new T4构造方法a();
  		//第四行自定义了一个带参数的构造方法，编译器不会在自动创建
  		//一个不带参数的构造方法故报错
  		//解决1，在第10行（）加上int 型参数
  		//解决2，在类体中，手动创建一个不带参数的构造方法
  	}
  
  	
  
  }
  
  

  this的特别之处：为什么说调用的是构造方法2，因为构造方法1是无参，而构造方法2是一个返回值为int型的构造方法-------------下图

  

  package 第七章_类和对象;
  //this调用构造方法
  public class T5构造方法b {
  	int i;
      //定义一个实例成员变量i
  	public T5构造方法b() {
          //定义一个无参数的构造方法
  		
  		this(1);
          //直接调用省去了public T5构造方法b(int i)方法，并指定，参数i=1
  	}
  	public T5构造方法b(int i) {
          //定义一个有参数的构造方法
  		this.i=i;
          //this引用成员变量i
  		System.out.println("i的值："+"\n"+i);
  	}
  	public static void main(String[] args) {
  		// TODO 自动生成的方法存根
  		T5构造方法b a=new T5构造方法b();
          //实例化类的对象
  		T5构造方法b b=new T5构造方法b(10);
          //实例化类的对象,在实例化时进行了类似于赋值的操作
  	}
  
  }
  
  
  

package 第七章_类和对象;

public class AnyThing {
	public AnyThing() {
		this("");
        //"this 调用有参构造方法"
		//在无参构造方法第一行使用this调用有参
		System.out.println("无参构造方法");
	}
    public AnyThing(String name) {
    	System.out.println("有参构造方法");
    }
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		AnyThing a=new AnyThing();
		//AnyThing b=new AnyThing();

	}

}

7.4.1.私有构造方法

• 

• 格式：被借类名 新变量名= 被借用名.要用的构造方法

分析：

Book是一个私有构造方法，而 libraryBorrow是一个属于Book这个私有构造方法的一个静态方法，在调用该方法时：类似子类继承父类一样

Book book = Book.libraryBorrow();

7.5.静态修饰符static

• 

• 静态区

• 

class AB{
  public static int a=0;
  public int b=1;
}
这个类
访问a的话 可以直接用 AB.a 而不需要实例一个AB对象
访问b的话需要 AB ab=new AB();
先得到一个AB的实例 再用ab.b;才能访问。

• 在本类或其它类使用格式, 类名.静态成员

package 第七章_类和对象;

public class T15静态成员 {
	final static double PI=3.1415;
	static int id;
	public static void method1() {
		//自定义一个静态方法
		System.out.println("静态方法");
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println(T15静态成员.PI);
		System.out.println(T15静态成员.id);
		//未进行初始化，则会自动填充int的默认值    0
		T15静态成员.method1();
		//因为是静态方法，所以不用类的实例化，直接调用静态方法

	}

}

• 注意：

  • 不可以在方法体中，对局部变量使用static，也就是说要对变量使用static，那就必须是成员变量

  • 

  • 静态区也是一种方法，所以不可以在静态区中使用static修饰局部变量

7.5.1.静态变量

• 

• package 第七章_类和对象;
  
  
  //静态变量static关键字的使用
  public class T8pool {
  	static public int water=0;
  	public void outlet() {
  		if(water>=2) {
  			water-=2;
              //water=water-2;
  		}else {
  			water=0;
              //water初始化
  		}
  	}
  	public void inlet() {
  		water+=3;
          //water=water+3;
  	}
  	public static void main(String[] args) {
  		// TODO 自动生成的方法存根
  	/*调用成员方法*/
  		T8pool in=new T8pool();
  		T8pool out=new T8pool();
  		System.out.println("poold的水量"+T8pool.water);
  	//T8pool.water无需进行对象实例化，water是静态变量，直接类名.静态变量名访问
  		in.inlet();
          //调用进水方法第一次
  		in.inlet();
          //调用进水方法第二次
  		System.out.println("进水两次后，pool水量："+T8pool.water);
  		out.outlet();
          //放水一次
  		System.out.println("放水一次后，pool水量："+T8pool.water);
  
  	}
  
  }
  
  

• 

• 静态成员变量调用

  • 对象1和对象2在内存中指向同一个内存区域，对象1、对象2任何一个对静态成员变量修改，另一个对象的值都会进行修改， 同一个内存区域

• 实例成员变量调用

  • 对象1和对象2在内存中分别指向·两个内存区域，对象1、对象2任何一个对静态成员变量修改，只会改变本身对象相应的内存区域的值，，另一个对象的值都不会进行修改， 两个不同内存区域

只要是成员变量，不管是静态还是非静态（实例成员变量），for方法等方法中，
 * 未进行重新定义，均可以直接引用，并初始化，
 * 区别：（1）静态的成员变量，for（方法）每次的操作，均会改变静态成员变量
 * 		   值
 * 	   （2）非静态成员变量，for（方法）每次操作，对非静态成员变量的改变，
 * 		   范围，仅仅局限于方法范围本身，不会对非静态成员方法本身产生影响*/				
			}

package 第七章_类和对象;

public class T16AccessProperty {	
	static int i=47;
	public void call() {
		System.out.println("调用call（）方法");
		for( i=0;i<3;i++) {
			System.out.print(i+"\t");
			if(i==2) {
				System.out.println("\n");
/*
 * 只要是成员变量，不管是静态还是非静态（实例成员变量），for方法等方法中，
 * 未进行重新定义，均可以直接引用，并初始化，
 * 区别：（1）静态的成员变量，for（方法）每次的操作，均会改变静态成员变量
 * 		   值
 * 	   （2）非静态成员变量，for（方法）每次操作，对非静态成员变量的改变，
 * 		   范围，仅仅局限于方法范围本身，不会对非静态成员方法本身产生影响*/				
			}
		}
	}
	public T16AccessProperty() {
        //创建无参构造方法
		
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//System.out.println(i);经实验证明，在方法中不进行重新定义
		//默认可以直接使用成员变量
		T16AccessProperty t1=new T16AccessProperty();
		T16AccessProperty t2=new T16AccessProperty();
		t2.i=60;
		//t1/t2指向内存同一个区域（静态成员变量i），
		//任何一个对象改变静态成员变量i的值，另一个随之改变
		System.out.println("实例化对象t1调用i的结果："+t1.i++);
        //+优先级大于++
		System.out.println("此时i的值是多少，为什么？"+i);
		System.out.println("使用括号改变优先级，实现t1.i++自增："+"\t"+(t1.i++));

		t1.call();
        //获取对象的行为
		System.out.println("t1调用成员方法call（）后，i的值为："+t1.i);
		System.out.println("单独输出i的值");
		System.out.println(i);
		/*
		 * i作为一个静态变量，静态也就是公共区，同时还是变量，也就是意味着
		 * 凡是属于该类的对象，均可以对其进行调用和改变其值，在t1.call()
		 * 调用call方法之后(获取对象的行为)，经过call方法的运行，i的值=0，1,2，当
		 * i=3时跳出循环，所以输出的值为3，验证，改变for循环的终止条件*/
		System.out.println("实例化对象t2调用i的结果："+t2.i);
		t2.call();
		//比较内存地址，equals是String类中比较内存地址上的内容
		System.out.println("对应的是同一个静态成员变量i，内存结果比较："+(t1.i==t2.i));
		System.out.println("一个对象一个引用（内存地址），t1和t2两个对象，对应两个内存地址，结果肯定："+(t1==t2));
		
		
	}

}

package 第七章_类和对象;

public class T9静态变量与实例变量差异 {
	static int x;
	int y;
	public T9静态变量与实例变量差异(int x,int y) {//构造方法
		this.x=x;
		this.y=y;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		T9静态变量与实例变量差异 a=new T9静态变量与实例变量差异(1,2);
		//进行类实例化对象（可以访问a.x或a.y），与第六行参数类型一致
		T9静态变量与实例变量差异 b=new T9静态变量与实例变量差异(11,22);

		System.out.println("a.x的值："+a.x);
		System.out.println("a.y的值："+a.y);
		//实例变量y进行类实例化对象后，可以a.y访问
		System.out.println("b.x的值："+b.x);
		System.out.println("b.y的值："+b.y);
	}

}

小漏洞：//将14行放到18行下面，可以避开静态变量值覆盖问题，就不会两次a.x=11（语句是从上至下，逐条读取）
非静态变量也就是“实例变量”

7.5.2.静态常量

package 第七章_类和对象;
//-----------------------------------------------------
public class T10静态常量 {
	final static double PI=3.1415926;
    //静态常量一般大写,一旦赋值不可更改
	/*圆的面积*/
	public static void main(String[] args) {
		@SuppressWarnings("unused")
		circular a=new circular(3.0);
		@SuppressWarnings("unused")
		spherical b=new spherical(3.0);
	}
}
/*（1）main方法入口处，程序启动处，public class与 class并无子集关系
     二者都是类，在定义构造方法时，为方便单独处理面积和体积，分别建立新类
     class circular 和 class spherical两个类
  （2）在一个程序中，公共类在有且仅有一个，其他类无限*/
//---------------------------------------------------
	class circular{
        //新建一个非公共类
		double radius;
        //圆的半径
		double area;
        //面积
		public circular(double radius) {
            //构造方法，返回值半径
			this.radius=radius;
            //指定使用class circular作用域的radius
			area=T10静态常量.PI*radius*radius;
            //类名.(PI来自于哪个类)
			System.out.println("圆得半径"+radius);
			System.out.println("圆的面积"+area);
		}
		
	}
/*计算面积的类，构造方法，传递参数半径*/
//--------------------------------------------------
	/*圆的体积*/
	class spherical{
		double radius;
		double volume;
		public  spherical(double radius) {
			this.radius=radius;
			volume=4/3*T10静态常量.PI*radius*radius*radius;
			System.out.println("圆得半径"+radius);
			System.out.println("圆的体积"+volume);
		}
	}
	/*计算体积的类，构造方法，传递参数半径*/
//-----------------------------------------------------
	

7.5.3.静态方法

• 背景：使用类的成员方法，必须先对这个类的实例化，如何在不想或者无法创建类的对象（不进行类的实例化）情况下，使用类的成员方法？
• 调用类的静态方法，无需创建类的对象，也就是无需进行类的实例化
• 静态方法中不可以使用this关键字
• 静态方法中不可以直接调用非静态方法（比如构造方法，要先实例化）

• 调用格式：静态方法所属的类名.静态方法名（);

package 第七章_类和对象;

public class T10staticMethod {//静态方法的使用
	static public void show() {
		System.out.println("使用类的静态方法时，无需进行类的实例化");
	}
	public static void main(String[] args) {
		T10staticMethod.show();
		//静态方法隶属于的那个类的名字.静态方法名字
	}

}

7.5.4.静态代码块

• 在类中，

  static{

  ​ }
  { }里面的代码就是静态代码块，该部分在类的声明时，就会运行

• 执行顺序：在Java运行区域顺序中，静态代码块>非静态代码块>构造方法>成员方法

• 

静态代码块也是静态方法，里面不可以直接用构造方法（要实力划），不可以使用this

package 第七章_类和对象;

public class T11staticTest {
//----------静态代码块---------------	
	static {
	System.out.println("---类声明时运行静态代码块--------");	
	}
//---------非静态代码块----------------
	{
		System.out.println("----------非静态代码块---------------");	
	
	}
//-----------构造方法------------
	public T11staticTest() {
		System.out.println("------------在new（进行类的实例化是）运行构造方法-----------");	

	}
//-----------成员方法------------
	public void method() {
		System.out.println("----------调用method方法时，成员方法运行---------------");	

	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		T11staticTest test=new T11staticTest();
		//类名 随机合法变量 =new 构造方法（）
		//在new时，构造方法运行
		test.method();
		//调用method方法时，成员方法运行
	}

}

7.5.5.类的主方法

• 每个类都可以有自己的main（）方法，但是在一个项目中，只可以有一个唯一的main（）方法

• 概念：类的入口点，定义程序从何处开始，主方法提供对程序流向的控制，Java编译器通过主方法来执行程序

• 格式

  • 主方法是静态的，所以如果要在主方法中直接调用其它方法，那么也必须是静态的（静态方法），若是构造方法这样的非静态方法，则必须创建对象的实例
  • public(公共的) static(静态的) void(不用返回值) main(方法名)
    String[]args 命令行参数
  • 主方法没有返回值，把void写成别的，就不是主方法了
  • 主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一一个参数到第n个参数，可以使用args.length获取参数的个数。
• 

package 第七章_类和对象;

public class T12eclipse设置程序参数 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(String tem:args) {
			System.out.println(tem);
		}

	}配置并输出数组args的参数

}
/*参数1第七章_类和对象右击，回车键分割不同变量
参数2运行方式
参数3运行配置
参数4自变量*/

7.6.对象的特性

• 背景

  • 一类事物中抽出来的某一个特例，充分体现出这一类的特点
  • 通过这一特例来处理这一类的事情
    每实例化一个对象就会自动调用一个构造方法，并执行构造方法中的内容，其实这个过程就是创建对象

• 创建

  • 使用new操作符调用构造方法就可以创建一个对象
• 

package 第七章_类和对象;

public class T13对象的引用2 {
	public T13对象的引用2() {
		 {
			System.out.println("\t"+"{"+"\n"+"\t"+"此处是非静态代码块"
			+"\n"+"\t"+"}");
		}
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new T13对象的引用2();
		/*T13对象的引用2 a=new T13对象的引用2()
		 * 实际上，是new T13对象的引用2()才是创建对象，
		 * 创建后，将内容赋值给a，所以，源码中，   new T13对象的引用2()
		 * 就可以了，因为这才是创建对象的本质，并且调用对应的构造方法
		 * 并将构造方法的内容执行*/
	}

}

• 引用
• 

package 第七章_类和对象;

public class T13对象的引用 {
	String name="西游记";
	public  String getName(){//String返回的类型为string，不可以用void
		return name;//getname（）这个成员方法的返回值为name
	}

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		T13对象的引用 b=new T13对象的引用();
		System.out.println(b.getName());
		System.out.println(new T13对象的引用().getName());
		//两者使用的效果一样，new T13对象的引用才是对象实体，b只是引用（符号代表）
	}
}

package 第七章_类和对象;

public class T14对象的使用 {
	int i=520;
	public void call() {
		for(int i=0;i<3;i++) {
			System.out.print(i+"\t");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		T14对象的使用 t1=new T14对象的使用();
		/*前面没有创建带参数的构造方法，所以虚拟机会自动
		 * 创建public T14对象的使用(){
		      }的构造方法，所以此处可以直接使用*/
		T14对象的使用 t2=new T14对象的使用();
		t2.i=1314;//创建的对象.成员变量，即可调用成员变量
		//调用成员变量，并改变初值
		
		System.out.println("第一次实例化对象，调用成员变量i的值："+t1.i);
		//未改变成员变量的初值
		System.out.println("第一次实例化对象，t1调用call的结果：");
		t1.call();
		System.out.println("第二次实例化对象，调用成员变量i的值："+t2.i);
		//成员变量的初值被改变
		System.out.println("第二次实例化对象，t2调用call的结果：");
		t2.call();//调用call方法

	}

}

• 比较

  • 方法
    ==
    比较的是对象引用的内存地址是否相等
    equals
    比较的是，对象引用的内存地址上的内容是否相等

• 内存地址与对象的关系

  • 一个对象只能对应一个地址
  • 可以多个对象对应同一个地址

package 第七章_类和对象;

public class T17对象比较 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String c1=new String("abc");
		String c2=new String("abc");
		String c3=c1;
		System.out.println("对应两个内存地址c1==c2结果："+(c1==c2));
		System.out.println("比较内存地址上的内容c1.equals(c2)结果："+(c1.equals(c2)));
		System.out.println("c1==c3结果："+(c1==c3));
		//c1和c3存在赋值关系，所以，这两个对象在内存中指向同一个内存地址



	}

}

对应两个内存地址c1==c2结果：false
比较内存地址上的内容c1.equals(c2)结果：true
c1==c3结果：true

• 销毁
• 

垃圾回收机制虽然完善，但是垃圾回收器只会回收new操作符创建的对象

• 现在科技水平已经很高了，内存和硬盘的容量也越来越大，硬件运行效率也非常快,所以一般程序产生的内存垃圾在现代化的硬件设备中显得太渺小了，加上Java虚拟机本身的垃圾回收能力非常强大，所以了解一下对象销毁的相关内容即可。