# Day07-Java基础

Posted 2021-09-01 zsr6135

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了# Day07-Java基础相关的知识，希望对你有一定的参考价值。

Day07-Java

1、static关键字

1.1 使用static关键字定义属性

在讲解static定义属性操作之前，首先编写如下一道程序。

现在定义一个表示中国人的操作类，所有人所在的国家为中国。

class Person{
	private String name;
	private int age;
	String country = "中国";
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getInfo(){
		return "姓名："+this.name+" "+"年龄："+this.age+"  "+"国家："+country;
	}
}
public class TestDemo1{
	public static void main(String args[]){
		Person per1 = new Person("张三",30);
		Person per2 = new Person("李四",40);
		Person per3 = new Person("王五",50);
		System.out.println(per1.getInfo());
		System.out.println(per2.getInfo());
		System.out.println(per2.getInfo());
	}
}

很明显，现在不管有多少个Person对象他的属性country的内容都是相同的，如果这时中国改名了，那么所有Person类的country属性都好更改，这样的话太过繁琐。

现在可以发现这样的问题：

1、country属性应该是一个公共的内容，但上面的代码是将其分配给每一个对象；

2、对country属性维护的时候要考虑的对象太多了，不便于维护。

所以如果想将country与普通属性相区分，并表示公共的概念，则应该使用static关键字完成。

class Person{
	private String name;
	private int age;
	static String country = "中国";
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getInfo(){
		return "姓名："+this.name+" "+"年龄："+this.age+"  "+"国家："+country;
	}
}
public class TestDemo1{
	public static void main(String args[]){
		Person per1 = new Person("张三",30);
		Person per2 = new Person("李四",40);
		Person per3 = new Person("王五",50);
		per1.country = "美国";
		System.out.println(per1.getInfo());
		System.out.println(per2.getInfo());
		System.out.println(per2.getInfo());
	}
}

那么现在对一个对象的属性country进行修改就一定会影响到其他对象的country属性，但是这里有个问题既然使用了static定义的属性表示一个公共属性，那么如果现在又一个对象进行修改是不合适的，应该有所有对象的集合的最大代表，就是类。即：static属性最好的调用，是通过“类名称.static属性”的方式来完成。

Person.country = “美国”; //类名称.static属性

通过本程序，就因该清楚一下几点：

1 使用static定义的属性不在堆内存之中保存，保存在全局数据区；

2 使用static定义的属性表示类属性，类属性可以由类型名称直接进行调用；

3static属性虽然定义在类之中，但是其可以在没有实例化对象的时候进行调用（普通属性保存在堆内存之中，static属性保存在全局数据区）

在以后的开发之中，首先想到的不是static属性，而是普通属性。

1.2 使用static定义方法

class Person{
	private String name;
	private int age;
	//static String country = "中国";
	private static String country = "中国";
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	//无法从静态上下文中引用非静态 变量 this
	//静态方法中没有办法使用this变量
	public static void setCountry(String c){
		country = c;
	}
	public static String getCountry(){
		return country;
	}
	public String getInfo(){
		return "姓名："+this.name+" "+"年龄："+this.age+"  "+"城市："+country;
	}
}
public class TestDemo1{
	public static void main(String args[]){
		/*Person per1 = new Person("张三",30);
		Person per2 = new Person("李四",40);
		Person per3 = new Person("王五",50);
		per1.country = "美国";
		System.out.println(per1.getInfo());
		System.out.println(per2.getInfo());
		System.out.println(per2.getInfo());*/
		//调用的方法必须为静态方法
		//姓名：张三 年龄：30  城市：中国人民共和国
		Person.setCountry("中国人民共和国");//没有实例化对象产生
		Person p1 = new Person("张三",30);
		System.out.println(p1.getInfo());
	}
}

以上的代码如果单独观察都不难理解，主要都是由于static定义的特殊性所决定的，但是现在的类之中就比较热闹了，分成了两类：static和非static，而对于方法的操作有如下两定义：

1、static定义的方法不能调用非static的方法或是属性；

2、非static定义的方法却可以调用static方法和static属性；

讨论：为什么要有这样的限制？

使用static定义的属性和方法，可以在没有实例化对象的时候调用，而非static方法必须在实例化对象之后才能调用。

1.3 分析主方法

在讲解主方法之前，思考一下小小的区别：在之前讲解Java方法定义格式的时候给过以下格式：如果一个方法在主类之中定义，并且有主方法直接调用的时候，前面必须有public static。

public class TestDemo{
	public static void main(String args[]){
		print();   //主方法直接调用
	}
	public static void print(){
		System.out.println("Hello World");
	}
}

按照之前所学习的概念来讲，此时，表示的是一个static方法调用其他的static方法，但是如果这个时候的print方法上没有static呢？所有非static方法几乎都有一个特点：非方法要由实例化对象调用。

public class TestDemo{
	public static void main(String args[]){
        //Hello,World!
		 new TestDemo().print();   //实例化对象调用非static方法
	}
	public  void print(){
		System.out.println("Hello,World!");
	}
}

主方法的组成：

Public:表示一个访问权限，表示公共
static：此方法由类名称直接调用，执行类：Java 类名称
void：主方法是一切的开始
main：系统规定的一个方法名称，执行类的时候默认找到此名称
String args[]：表示的是一些运行时参数，通过字符串接收

public class TestDemo2{
	public static void main(String args[]){
		for(int x = 0;x<args.length;x++){
			System.out.println(args[x]);
		}
	}
}

1.4 关键字的使用

在实际的工作之中，使用static的原因有两个：

希望可以在没有实例化对象的时候可以轻松的执行类的某些操作
现在希望表示出数据共享的概念

统计一个类的实例化对象的个数

class Person{
	private String name;
	static int num = 0;
public Person(){
	num++;
} 
public void setName(String name){
	this.name = name;
}
public String getName(){
	return name;
}
}
public class TestDemo3{
	public static void main(String args[]){
		Person per1 =new Person();
		Person per2 =new Person();
		Person per3 =new Person();
		Person per4 =new Person();
		System.out.println(Person.num);
	}
}

2、代码块

2.1 普通代码块

public class PuTongDaiMaKuai{
	public static void main(String args[]){
		{ //普通代码块
			int x = 10;                //局部变量
				System.out.println("x ="+x); 
		}
		int x = 100;               //全局变量
		System.out.println("x ="+x);
	}
}


//x =10
//x =100

2.2 构造块

class Person{
	public Person(){
		System.out.println("构造方法1")
	}
	{
		System.out.println("构造块2");
	}
}
public class PuTongDaiMaKuai{
	public static void main(String args[]){
		new Person();
		new Person();
		new Person();
	}
}

/*
构造块2
构造方法1
构造块2
构造方法1
构造块2
构造方法1
*/

可以发现，构造块优先于构造方法先执行，而且每当有一个新的实例化对象产生的时候，就会出现构造块的执行。

2.3 静态块

静态块也是定义在类之中的，如果一个构造块上使用了static关键字进行定义的话，那么就表示静态块，但是静态块要考虑两种情况。

情况一：在非主类之中定义的静态块

class Person{
	public Person(){
		System.out.println("构造方法1");
	}	
	{//构造块		
	System.out.println("构造块2");
	}	
	static{//静态块		
	System.out.println("静态块3");
	}
}
public class JingTaiKuai{
	public static void main(String args[]){
		new Person();		
		new Person();		
		new Person();	
		}
}/*构造块3构造块2构造方法1构造块2构造方法1构造块2构造方法1*/

可以发现，静态块优先于构造块，而且不管产生多少实例化对象，静态块只调用一次。

情况二：在主类中定义的静态块

public class TestDemo4{
	static{
		System.out.println("静态块");
	}
	public static void main(String args[]){
	System.out.println("主方法");
	}
}

/*
静态块
主方法
*/

在主类之中的静态块优先于主方法执行，那么既然静态块有这个特点，我们可以加以利用。

3、继承性

Person java:

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}

Student java:

class Student{
	private String name;	
	private int age;	
	private String school;	
	public void setName(String name){		
		this.name=name;	
	}	
	public void setAge(String age){
		this.age=age;	
	}	
	public void setSchool(String school){
		this.school=school;
	}	
	public String getName(){
		return name;	
	}	
	public int getAge(){		
		return age;	
	}	
	public String getSchool(){		
		return school;	
	}
}

可以发现里面有一大部分的内容已经重复了，但是现在抛开程序不谈，学生和人的关系是：学生就是一个人，但是学生类比人类的定义更加严格，此时按照之前的概念肯定无法解决问题。

3.1 继承的实现

在Java中，如果想要明确的实现继承的关系，则可以使用extends关键字完成，格式如下：

//但是在这里需要注意的是：子类又被称为派生类；
//父类也被称为超类（super class）
class 子类 extends 父类{}

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}
class Student extends Person
{
}
public class TestDemo5{
	public static void main(String args[]){
	Student stu = new Student();
	stu.setName("张三");
	System.out.println(stu.getName());
	}
}

通过程序的运行我可以发现，现在在子类之中，没有定义任何方法，而是可以直接将父类中定义的操作继续使用，所以在子类之中可以对父类进行重用，当然，子类也可以定义属于自己的操作。

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}
class Student extends Person{
	private String school;
	public void setSchool(String school){
		this.school = school;
	}
	public String getSchool(){
		return this.school;
	}
}
public class TestDemo5{
	public static void main(String args[]){
	Student stu = new Student();
	stu.setName("张三");
	stu.setSchool("宾夕法尼亚大学");
	//name = 张三,school = 宾夕法尼亚大学
	System.out.println("name = " + stu.getName()+ ",school = " +stu.getSchool());
	}
}

通过以上程序了一发现，在开发语言之中，子类最基本的功能就是维持父类的原本操作，所以在程序语言之中并不会存在所谓的现实生活中的“败家子”的概念。所以通过程序可以发现，继承的功能就是对已有类功能的一种扩充。

3.2 继承的限制

在使用继承关系后，子类对象在实例化对象前一定首先实例化父类构造方法，再调用子类的构造方法后子类再进行实例化操作。——现实生活之中，没有老子，也绝对没有后代，肯定是老子先出来，之后在轮到小的再出来，所以这样的实例化方式非常吻合现实生活，如果在调用子类构造之前先去调用父类构造就可以证明是先实例化父类对象，而后再实例化子类对象。
Java中只允许单继承，不允许多继承。
在进行继承的时候，子类会继承父类所有的结构。所有的非私有操作采用显式继承的方式，所有的私有操作采用隐式继承的方式。——按之前的开发所讲，一个类中的全部内容肯定都被子类继承，对于之前学生和人之间的操作，学生类也继承了Person类中的name和age两个属性，这两个属性是间接继承（隐式继承），只能通过方法访问

class Person{
	public Person(){
			System.out.println("父类构造");
	}
}
class Student extends Person{
	public Student(){        
	//既然是进行构造方法的调用，必须写再首行位置		
	super();//此语句再无参时写与不写一样		
	System.out.println("子类构造");
	}
}
public class JiChengXing{
	public static void main(String args[]){
		new Student();
	}
}

而如果说现在父类中没有明确的无参构造方法，这个时候就可以利用sup

以上是关于# Day07-Java基础的主要内容，如果未能解决你的问题，请参考以下文章

day06-jsp

Day07：JAVA常用类

[vscode]--HTML代码片段（基础版，reactvuejquery）

[Go] 通过 17 个简短代码片段，切底弄懂 channel 基础

AI基础_Day02

Java基础Day5