1~5章作业本和实验

作业题：
java哪三个版本 javaSE标准版 javaEE企业版 javaME
java程序开发过程：
编写源文件 编译原文件 运行程序
关于常量的初始化：
如果类变量没有初始化的话，就会自动赋零，false 或者是NULL,而方法中的变量没有初始化的话就会报错.
（当成员变量和局部变量被fina修饰时，注意一下）
方法重载
在一个类中，方法名相同，但是参数个数和参数类型不同。
方法覆盖
子类的方法名与父类的方法名相同，子类不能继承的父类的方法，此时子类的方法覆盖父类的方法。
接口与抽象类的差别：
（接口：public static final 常量
public abstract 方法）
（抽象类：抽象类不能被实例化，也不能创建其对象。
抽象方法：在抽象类中创建的，必须在子类重写的方法叫抽象方法。
抽象方法不能被private或static修饰
对于static：
1：方法不能被覆盖，这个类的子类不能有相同的方法名、参数的方法。
2：static方法只能访问static方法（static方法也就是类方法不能直接操作实实例方法，因为实例方法只有在创建对象的时候才会分配入口地址。）
3：static方法只能访问static数据成员）
差别1：接口中只能定义抽象方法而抽象类中可以定义抽象方法和普通方法
接口中不能定义静态方法，抽象类中可以定义静态方法
差别2：接口中不能包含构造器，抽象类中可以包含构造器，其作用是让子类初调用并完成始化操作的。
接口中不能包含初始化块，而抽象类中可以包含初始化块
差别3：接口中只能定义静态常量属性，不能定义普通属性：抽象类可以定义静态常量属性，也可以定义普通属性。
实验一：
Eclipse的Debug模式，掌握在Eclipse中调试程序的方法（好像没用过，不用就忘了）
(https://blog.csdn.net/qq_37591637/article/details/83338438)

关于几个环境变量的设置：
环境变量“JAVA_HOME”：使其它相关环境变量的配置更加方便简洁
“PATH”:帮助系统操作java，用javac将源代码编译成class文件，在调用java命令让程序执行
“CLASSPATH：告诉java执行环境，在那些目录下可找到要执行的Java程序
实验二、
任务一的相关问题：
任务一：
char x=’\117’,y=117,z=0X41;
System.out.println(x+" “+y+” "+z);
输出的结果是：
O u A
'\117’是大写的O（ASCII码八进制表示）
117是u（十进制表示）
0x41就是A（‘0X’ASCII码十六进制表示）

**关于变量：**成员变量（类变量和实例变量作用于成员函数和类里面）局部变量（方法体里面），变量的作用范围也要好好注意
类变量可以用类直接访问（类变量是属于类的，任何一个对象可以拥有这个变量，每一个对象用的都是同一个类变量，只分配一次内存空间，也就是说当类变量改变了，所有对象的这个类变量就都改变了）
对象的使用是可以用实例化后的对象调用类中的成员变量和成员方法。
为什么不可以在main方法外实例化对象这个问题先缓缓。

参数传值和引用传值的区别，
引用传值把原始的数据都改变了，而参数传值改变的只是原始数据的副本，原始数据没有改变。

访问权限：
private 只能在自己这个类中使用
friendly 在一个包中使用
protected
在继承中的方法覆盖和方法重载
应该也差不多
关键字
public和protected感觉基本一致
private就是不能继承因为肯定不在同一个类中
在同一个包中的的友好型的成员变量和成员方法还是可以继承的
继承中构造函数的说明
子类在构造函数中就会首先去调用父类的构造，默认调用的是父类的无参构造。
如果你需要参数个数不同的构造，可以在父类中写多个构造方法的。子类继承父类的方法中不包含构造方法、。t
this和super
this和super都只对象，不可再static环境中使用
super：在子类中操作父类隐藏的成员变量和被覆盖的成员方法
this：当局部变量和成员变量同名时，成员变量会被隐藏，此时如果在成员方法中使用成语变量，就是用this关键字。
（关于构造函数）
this和super不能出现在同一个构造函数
this **参数相当于调用本类中另一形式的构造函数，在一个成员函数内部，在调用一个成员函数，可以直接写方法名，而在外部就是对象名+方法名调用。
super调用父类中某一构造函数

//代码中的部分注释代码可以去掉，来查看各种构造函数的调用结果
/*1、如果父类没有定义构造函数，系统会默认定义一个无参无返回值的构造函数，子类继承时无需（无需的意思是：可以写可以不写）在子类构造函数中显式调用super( )；
 * 如果父类定义了构造函数，系统不会再默认定义任何 无参无返回值 的构造函数,此时子类的构造函数中必须显式调用super( [arg0][,arg1]….),即，显式调用对应的参数个数、
对应参数类型与此super( [arg0][,arg1]…. )的父类构造函数。
2、super指代 父类对象 可以在子类中使用 super.父类方法名();调用父类中的方法（无论是类方法还是实例方法都可以，除此调用实例方法的还可以在方法内部实例化再调用）*/ 
class Person {
	public Person() {
		System.out.println("子类调用 父类 无参 构造函数");
	}

	public Person( String j) {
		System.out.println("子类调用父类有参的构造方法 "+"传递参数为"+j);
	}
	public Person( int i,String j) {
		System.out.println("父类的构造函数");//就输出空行吧
	}
}

public class Chinses extends Person {
	/*
	 * public Chinses(int b,String a)  {
	 * this(name);//****/this **参数相当于调用本类中另一形式的构造函数，这个调用的也就是public  Chinses(String a)****
	 * System.out.println("子类调用父类具有相同形式的构造函数！"+"传递参数"+a+"   "+b); }
	 */	
	/*
	 * public Chinses(int b,String a)  {
	 * System.out.println("子类调用父类具有相同形式的构造函数！"+"传递参数"+a+"   "+b); }
	 */ 
	/*//调用：public Person( int i,String j) 
	 * public Chinses(int c,String a) { 
	 * super(c,a); }
	 */
	
 public Chinses(int b,String a) {
		/* 1、子类所有的 构造函数 默认调用父类的无参构造函数（其实是默认省略掉了一行代码：super();）;也就是说 回调用父类中 public Person() ，没有super（）也会默认调用
		 * 省略掉的这行super()代码可以自行添加到构造函数的第一行（必须是第一行，否则报错）
	 	 */   
 System.out.println("子类调用父类具有相同形式的构造函数！"+"传递参数"+a+"   "+b);
 } 
	public Chinses() {//4、自行添加super(val1,val2,…),就可以指定调用父类的那个参数类型和数量一致的构造函数。之后在此子类构造函数中，系统不会再默认调用父类无参构造函数；
		 super();//这个就是相当于调用父类无参构造方法
	}

	public Chinses(String a) {
		super( a);//这个就是相当于调用父类有参构造方法
	} 
	public static void main(String args[]) {
		Chinses fa = new Chinses();
		Chinses son1 = new Chinses("Hello!");
		Chinses son2 = new Chinses(18,"Hi");
	}
	
}

向上转型：
一个对象可以看做是本类的类型，也可以看做是它的父类的类型。取得一个对象的引用并将它看做父类的对象。（实例）

12、OK编写一个ComputerAverage抽象类，
类中有一个抽象方法求平均分average，可以有参数。
定义Gymnastics类和School类，它们都是ComputerAverage的子类，
Gymnastics类中计算选手的平均成绩的方法是去掉一个最低分，去掉一个最高分，然后求平均分。School中计算平均分的方法是直接是总分除以总科目。
在main方法中，通过向上转型调用重写的方法averge，用不同的方法计算平均成绩。   
 abstract class ComputerAverage {
abstract float average();
}
 
public class Result {
	int grade[]={1,2,3,4,5};//15
	 int len=grade.length;
	 public float run(ComputerAverage a) {
		return a.average();
	}
	public static void main(String[] args){
		ComputerAverage a=new Gymnastics();//去掉后求
		ComputerAverage b=new School(); //直接求
		Result r=new Result();
		System.out.println("去掉一个最高分和最低分后的平均分"+r.run(a));
		System.out.println("不去掉一个最高分和最低分后的平均分"+r.run(b));
	} 
}
class Gymnastics extends ComputerAverage{//去掉一个最高分和最低分
	int i,sum,max,min;
	
	public	float average(){ 
		Result c=new Result(); 
	max=c.grade[0];
	min=c.grade[0];
		for(i=1;i<c.len;i++){
		 if(c.grade[i]>max) {
			 max=c.grade[i];
		 }else {
			min=c.grade[i]; 
		 }
		sum=sum+c.grade[i];
	} 
		return (sum-max-min+c.grade[0])/(c.len-2);
	}
}

class School extends ComputerAverage{//直接求平均分
	int i;
	float sum; 
		public	float average(){
			Result c=new Result(); 
			for(i=0;i<c.len;i++){
				sum=sum+c.grade[i];
			}
			return sum/c.len;
		}	
}  

实验三中很好的一串代码（在我看来，主要是输入问题的解决）

import java.util.Scanner;  
class Account1 {
	String username;//用户信息
	String accountname;//账户信息
	float deposit;//存款
	float balance;//余额
	public Account1(float deposit){//
		this.deposit=deposit;
	}
	public void showdeposit(){//显示余额
		if(deposit>=0){ 
		System.out.println("余额是"+deposit);
	}else{
		System.out.println("余额不足");
	}
		}
	public void showname(){//显示信息
		System.out.println("显示用户信息"+username);
		System.out.println("显示账户信息"+accountname);
	}
	public void inmoney(float in){//存款
		deposit=in+deposit;
	}
	public void outmoney(float out){//取款
		deposit=deposit-out;
	}
 
}

public  class Bank1{ 
	public void initial ( Scanner sc,Account1 a) { 
		 System.out.println("请输入账户名："); 
		  a.accountname=sc.nextLine(); 
		//  sc=new Scanner(System.in); 
 	 System.out.println("请输入用户名：");
 			 a.username=sc.nextLine(); 
 			 
	}
	  public static void main(String[] args){ 
		  int judge; 
		 Scanner sc=new Scanner(System.in); 
		 Account1 a=new Account1(100);//初始化存款为100
		 Bank1 i=new Bank1();
		 i.initial(sc,a);
 	 System.out.println("请选择：查询信息请输入1，存款请输入2，取款请输入3.输入其他退出"); 
 	 judge=sc.nextInt();
		 while((judge>=1)&&(judge<=3)){  
		 if(judge==1){
			 a.showname();
			 a.showdeposit();  
		 }else if(judge==2){
			   System.out.println("请输入存入数目");
			 a.inmoney(sc.nextFloat());  
		 }else if(judge==3){
			 System.out.println("请输入取出数目");
			 a.outmoney(sc.nextFloat());  
			 
		 }else{  
			 judge=0;
		 } 
		 sc=new Scanner(System.in); 
		 judge=sc.nextInt();
 	
 	}
		 sc.close();
 	a.showname(); 
		 a.showdeposit(); 
 }
}

第二个不错的

（1）构造方法：提供几种初始化方式，
包括没有参数的构造方法（实部与虚部都为0），
用一个浮点数初始化实部的构造方法（虚部为0），
以及用两个浮点数初始化实部与虚部的构造方法。
（2）复数加/减法：将当前复数与形式参数指定的复数相加/减，
得到一个新的复数
任务九：
public class Complex {
	float real,im;
	public Complex(){
	real=0;
	im=0;
	}
	public Complex(float real,float b){
		this.real=real;
		this.im=b;
	}
	public Complex(float real){
		this.real=real;
		 im=0;
	}
	 public Complex add (Complex c){
		 Complex d=new Complex();
		 d.real=c.real+real;
		 d.im=c.im+im;
		 return d;
		 
	 }
	 public Complex sub (Complex c){
		 Complex d=new Complex();
		 d.real=real-c.real;
		 d.im=c.im-im;
		 return d;
		 
	 }
	  
	 public void showraddesult(Complex c){
		  if(c.im==0){
	    	 System.out.println(c.real); 
	     }
	     else{ 
         System.out.println(c.real+"+"+c.im+"i");
          } 
	 }
	 public void showsubresult(Complex c){
		  if(c.im==0){
	    	 System.out.println(c.real); 
	     }
	     else{ 
        System.out.println(c.real+"-"+c.im+"i");
         } 
	 } 
	 public static void main(String[] args){
		 Complex a=new Complex();//实部虚部都为零
		 Complex b=new Complex(4,5);//虚部为零
		 Complex d=new Complex(2,3);
		 Complex c=new Complex();
	     c=a.add(b);
	     System.out.println(a.real+"+"+a.im+"i"+"加上"+b.real+"+"+b.im+"i"+"的结果是："); 
	     c.showraddesult(c);
	     
	    c=a.add(d);
	    System.out.println(a.real+"+"+a.im+"i"+"加上"+d.real+"+"+d.im+"i"+"的结果是："); 
	     c.showraddesult(c);
	     
	     c=a.sub(b);
	     System.out.println(a.real+"+"+a.im+"i"+"减去"+b.real+"+"+b.im+"i"+"的结果是："); 
	     c.showsubresult(c);
	     
	    c=a.sub(d);
	    System.out.println(a.real+"+"+a.im+"i"+"减去"+d.real+"+"+d.im+"i"+"的结果是："); 
	     c.showsubresult(c); 
	 } 
}

第六章接口–t特殊的抽象类
接口可以实现多继承，在类中实现接口时，方法的名字，返回值类型，参数个数类型必须与接口完全一致，并且必须实现接口中所有方法。
接口点.常量名 就可以访问这个接口中的 常量。
接口回调
接口回调指的是，把实现某一接口的类所创建的对象的引用赋值给该接口声明的接口变量。，那么接口变量就可以调用被类实现的接口方法。
接口回调的作用： 接口变量调用别类实现的接口方法时，通知相应的对象调用这个方法。恩，实例更重要：

interface Soundable {
	// 使用抽象方法
	public void playSound(); 
	public void stopSound();
}

// 设计新的类Radio，再用Radio来创建对象,进行接口的实现，使用implements关键字
class Radio implements Soundable {
	public void playSound() {// 定义playSound()的处理方式
		System.out.println("收音机播放广播：中央人民广播电台");
	} 
	public void stopSound() {
		System.out.println("关闭收音机");
	}
}

class SampleDisplay {
	public void display(Soundable sound) {// 接口申明的接口变量，这里定义了接口类型的参数，可以更好的用接口回调
		sound.playSound(); 
		sound.stopSound();
	}
} 
// 测试类
public class SoundTest {
	public static void main(String[] args) {
		System.out.println("听收音机");
		SampleDisplay SampleDisplay = new SampleDisplay();
		Radio  sound=new Radio ();
		SampleDisplay.display(sound);
	}
}

这个代码吧，使用了接口回调，而且使用的是接口类型的函数

下面的代码用来实现对大货车和小货车上的不同货物重量的统计， 
 interface ComputerWeight { 
public double computerWeight();
}

class Television  implements ComputerWeight{
public double computerWeight(){
return 100;
}
}
class Computer implements ComputerWeight{
public double computerWeight(){
return 100;
}
} 
class WashMachine implements ComputerWeight{
public double computerWeight(){
return 100;
}
} 

class Car{
ComputerWeight[] goods;
double totalWeights=0;
Car(ComputerWeight[] goods){
this.goods=goods;
}
public double getTotalWeights(){//计算totalWeights
for(int i=0;i<goods.length;i++){
totalWeights=goods[i].computerWeight()+totalWeights;
}
return totalWeights;
}
}

public class Road{

public static void main(String[] agrs){
ComputerWeight[] goodsOne=new ComputerWeight[50], goodsTwo=new ComputerWeight[22];
for(int i=0;i<goodsOne.length;i++)
{   if(i%3==0)
goodsOne[i]=new Television();
else if(i%3==1)
goodsOne[i]=new Computer();
else if(i%3==2)
goodsOne[i]=new WashMachine();
}
for(int i=0;i<goodsTwo.length;i++)
{   if(i%3==0)
goodsTwo[i]=new Television();
else if(i%3==1)
goodsTwo[i]=new Computer();
else if(i%3==2)
goodsTwo[i]=new WashMachine();
}

Car c1=new Car(goodsOne);
System.out.println("大货车转载的货物重量："+c1.getTotalWeights());
Car c2=new Car(goodsTwo);
System.out.println("大货车转载的货物重量："+c2.getTotalWeights());
}
}

第七章异常处理（恩，目前不是很了解，简单点）

catch语句块用来捕获一种类别的异常
Throw用于方法体内，并且抛出一个异常对象，
Throws是声明方法时候抛出的，用来指定方法可能抛出的异常。

//由这个代码可知首先finally一定是接在catch语句后，catch代码块中如果发生异常后面的语句（除了finally以外的）是不会执行的。若catch语句中没有异常还是会执行的，具体可以自己尝试。
public class Test {
public static void main(String[] args) {
try {
int age;
Scanner sc=new Scanner(System.in);
age=sc.nextInt();
System.out.println("正常");
		sc.close();
}catch(Exception e) {
	System.out.println("8/0的答案是"+8/0); 
System.out.println("错误是"+e.getMessage());
}
finally {
System.out.println("异常处理");
}
System.out.println("执行情况"); 
}
}

关于自定义异常类

/*创建Score类，定义一个check(int score)方法，其中score是考试分数，如果分数在0-100之间输出“分数正常”，如果分数小于0或大于100，使用throw抛出异常信息“分数只能在0-100之间”。用户从键盘输入考试分数，调用check(int score)方法对分数进行检测，使用try、catch语句检查是否存在异常，并输出相应的信息。修改代码，自定义一个异常类，完成同样的功能。 
结果如下所示：
（1）
请输入分数：123
分数只能在0-100之间
（2）请输入分数：87
分数正常
*/
import java.util.*;
public class Score {
	public void check(int score) throws MyException {//throw抛出异常后，想让上一级代码捕获并处理异常，则需使用throws关键字在方法的声明中指明要抛出的异常。如果在当期方法抛出，就要使用try...catch语句。
if(score>=0&&score<=100) {
System.out.println("分数正常");
}else {
throw  new MyException();//throw抛出的是一个异常对象
}
} 
public static void main(String[] args) {
try {
int score;
Score s=new Score();
Scanner sc=new Scanner(System.in);
System.out.println("请输入分数");
score=sc.nextInt();
sc.close();
s.check(score);
}catch(MyException e){
e.say();
}
} 
}

class MyException extends Exception{
public void say() {
System.out.println("分数只能在0-100之间");
}
 }