//1、成员变量、局部变量的区别? Java 几种基本类型成员变量默认初始化的值？
/**区别：
a、在类中的位置不同成员变量：在类中方法外面局部变量：在方法或者代码块中，或者方法的声明上（即在参数列表中）；
b、在内存中的位置不同，可以看看Java程序内存的简单分析成员变量：在堆中（方法区中的静态区）局部变量：在栈中；
c、生命周期不同成员变量：随着对象的创建而存在，随着对象的消失而消失 局部变量：随着方法的调用或者代码块的执行而存在，
随着方法的调用完毕或者代码块的执行完毕而消失；
d、初始值 成员变量：有默认初始值 局部变量：没有默认初始值，使用之前需要赋值，否则编译器会报错。
几种基本类型成员变量默认初始化的值
byte short int 0
long 0L
char 空格
float 0.0f
double 0.0d
boolean false
*/
//2、 方法重载和方法重写区别?
/**
* 方法的重写Overriding和重载Overloading是Java多态性的不同表现。
* 重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
* ---------------------------------------------------------------------------------
* override重写 | overloading重载
* |
* 方法名，参数类型，返回值类型全部相同 | 方法名相同，参数类型个数不一定相同
* 被重写的方法不能缩小父类方法的访问权限 | 对权限没有要求
* 发生在继承类中 | 发生在一个类中
* |
------------------------------------------------------------------------------------
*
* */
//3、 能根据根据返回类型来区分重载，为什么？
/**
* 不能；
* 因为调用时不能指定返回类型信息，编译器不知道你要调用哪个函数。
*
*
* */
//4、 this和super以及final关键字的作用是什么？
/**
this关键字
如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
在一个构造函数中可以调用另外一个构造函数初始化对象
super关键字
子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。
final关键字
修饰全局变量：该变量为一个全局的常量（全局常量一定要赋初始值，全局变量可以不赋初始值）。
修饰局部变量：变为局部的常量，仅在所在的代码块中有效。
修饰类：则该类为最终类，即没有子类不能被继承
修饰方法：则该类不能被重写，成为最终方法
*/
//5、 java代码块的分类和特点以及加载顺序？
/**
* 分类:局部代码块，构造代码块，静态代码块，同步代码块
*
* 特点：局部代码块:直接在出现在一个方法中的{};限定变量生命周期，及早释放没用的对象，变量等，提高内存利用率
* 同步代码块：synchronized关键字 ,主要出现在多线程中
* 构造代码块:直接在类中定义的没有加static关键字的代码块{}称为构造代码块，用于对象进行初始化。
* 静态代码块:static关键字声明;用来为静态属性初始化 ;只执行一次
* 加载顺序：静态代码块–>构造代码块–>构造函数
*/
/*6、下面的程序可以运行么？说明原因？如果不能运行该如何修改？
public class Test {
public static void main(String args[]) {
Foo obj = new Foo();
}
}
class Foo{
int value;
public Foo(int intValue){
value = intValue;
}
}*/
/**
* 不能运行；编译出错；因为没有空的构造函数；
* 解决办法：
* a. Foo obj = new Foo(); 加一个int 类型参数
* b.foo类加一个空的构造函数
*
*/
/*7、 class Varialbe {
int num = 12;
public void show1() {
int num = 50;
System.out.println(num);
}
public void show2(){
int num2;
System.out.println(num2);
}
public static void main(String[] args){
Varialbe varialbe = new Varialbe();
varialbe.show1();
varialbe.show2();
}
}
上述程序运行结果分别是？说明原因？*/
/**
* 编译出错，无法运行 num2未实例化
* 把错误排除后num的值为50 num2的值是实例化后的值
*
*/
/*8、
class Person{
private String name ; // 姓名
private int age ; // 年龄
public Person(String name,int age){
name = name ;
age = age ;
}
public String getInfo(){
return "姓名：" + name + "，年龄：" + age ;
}
};
public class ThisDemo01{
public static void main(String args[]){
Person per1 = new Person("张三",33) ;
System.out.println(per1.getInfo()) ;
}
};
上述程序运行结果？说明原因？*/
/**
* 姓名：null，年龄：0
* 未加this关键字
*/
/*9、
public class JqTest {
public static String staticField = "晶奇科技";
public String field = "JQKJ";
static {
System.out.println( staticField );
}
{
System.out.println( field );
}
public JqTest()
{
System.out.println( "晶奇" );
}
public static void main( String[] args )
{
new JqTest();
}
}
上述程序运行结果？说明原因？*/
/**运行结果
晶奇科技
JQKJ
晶奇
原因：再不考虑继承等情况下 静态代码块最先按顺序执行 ， 构造代码块 其次执行 ， 构造方法最后执行
*/
/*10、
下列有关整型的最终属性i的定义正确的是哪些？并列出错误原因
A．static int i;
B．final i;
C．static finalint i = 50;
D．final float i= 1.2;*/
/**A 又因为是最终属性 所以 要用final限制
* B错误 不是整型
* C正确
* D错误 不是整型
*/
import java.text.DecimalFormat;
/**
* 11、 创建一个类，为该类定义三个构造函数，分别执行下列操作：
* 1、传递两个整数值并找出其中较大的一个值
* 2、传递三个double值并求出其和（注意精度）
* 3、传递两个字符串值并检查其是否相同
* 4、在main方法中测试构造函数的调用
*
*
*/
public class TestConstruction {
// 1、传递两个整数值并找出其中较大的一个值
public TestConstruction(int a, int b) {
if (a > b) {
System.out.println(a);
} else {
System.out.println(b);
}
}
// 传递三个double值并求出其和（注意精度）
public TestConstruction(double a, double b, double c) {
DecimalFormat df = new DecimalFormat("#.0000");
double sum = 0.0;
sum = a + b + c;
System.out.println(df.format(sum));
}
// 传递两个字符串值并检查其是否相同
public TestConstruction(String s1, String s2) {
if (s1.equals(s2)) {
System.out.println("相同");
} else {
System.out.println("不相同");
}
}
public static void main(String[] args) {
new TestConstruction(2, 3);
new TestConstruction(2.1, 3.1, 1.1);
new TestConstruction("s1", "s2");
new TestConstruction("s1", "s1");
}
/**
* 3
6.3000
不相同
相同
*/
}
/**
* 创建一个员工类(Employee)，其中包括： 1）
* 4个属性：员工姓名(name)、员工年龄(age)、员工职位(position)、工资(salary) 2） 方法： Employee()
* ——给所有的属性指定初始值 setName（）——给name属性赋值
* setAge（）——给age属性赋值，要求年龄必须在18岁以上，当年龄无效时，将年龄强制赋值为18，并在控制台打印"年龄输入不符合要求,默认为18"
* setPosition（）——给position属性赋值，只能是“售后服务”和“销售员”，如果不符合要求，强制将职位赋值为“售后服务”
* 并在控制台打印"职位输入不符合要求,默认为售后服务",。 setSalary（）——用于员工的工资：根据员工的年龄段不同，给工资属性赋值，具体要求：
* 18~20岁之间，1000元，21~25岁之间，1500元，26~30岁之间，2000元，31~40岁之间，3000元，41~50岁之间，3500元，
* 50岁以上,4000元 getName（）——返回name属性 getAge（）——返回age属性 getPosition（）——返回position属性
* getSalary（）——返回salary属性
* 测试类TestEmployee，在该类中创建3个Employee对象，
* 通过键盘输入给3个员工的名字、年龄、职位进行赋值，打印出员工的各项信息（名字，职位，年龄，工资），显示出员工的信息;
* (注：不一定按照上面去写,可按照自己对面向对象的理解去设计)
*
*
*/
public class Employee {
private String name;
private int age;
private String position;
private float salary;
public Employee(String name, int age, String position, float salary) {
super();
this.name = name;
this.age = age;
this.position = position;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age < 18) {
this.age = 18;
System.out.println("当年龄无效时，默认为18");
} else {
this.age = age;
}
}
public String getPosition() {
return position;
}
public void setPosition(String position) {
if (position.equals("售后服务") || position.equals("销售员")) {
this.position = position;
} else {
this.position = "售后服务";
System.out.println("输入不符合要求，默认为售后服务");
}
}
public float getSalary() {
return salary;
}
public void setSalary() {
if (age >= 18 && age <= 20) {
this.salary = 1000;
} else if (age >= 21 && age <= 25) {
this.salary = 1500;
} else if (age >= 26 && age <= 30) {
this.salary = 2000;
} else if (age >= 31 && age <= 40) {
this.salary = 3000;
} else if (age >= 41 && age <= 50) {
this.salary = 3500;
} else if (age >= 51) {
this.salary = 4000;
} else {
System.out.println("没有设置年龄或者年龄无效");
}
}
@Override
public String toString() {
return "Employee [name=" + name + ", age=" + age + ", position=" + position + ", salary=" + salary + "]";
}
}
================================================================================
public class TestEmployee {
@Test
public void test1() {
Employee e1 = null;
List list = new ArrayList<>();
Scanner sc = null;
for (int i = 0; i < 3; i++) {
e1 = new Employee(null, 0, null, 0);
sc = new Scanner(System.in);
System.out.println("请输入第" + (i + 1) + "个员工姓名：");
String name = sc.next();
e1.setName(name);
System.out.println("请输入第" + (i + 1) + "个员工年龄：");
int age = sc.nextInt();
e1.setAge(age);
System.out.println("请输入第" + (i + 1) + "个员工职位：");
String position = sc.next();
e1.setPosition(position);
e1.setSalary();
list.add(e1);
System.out.println();
}
sc.close();
for (Employee employee : list) {
System.out.println(employee.toString());
}
}
/**
*
* 请输入第1个员工姓名：
a
请输入第1个员工年龄：
12
当年龄无效时，默认为18
请输入第1个员工职位：
售后服务
请输入第2个员工姓名：
b
请输入第2个员工年龄：
28
请输入第2个员工职位：
销售员
请输入第3个员工姓名：
c
请输入第3个员工年龄：
12
当年龄无效时，默认为18
请输入第3个员工职位：
d
输入不符合要求，默认为售后服务
Employee [name=a, age=18, position=售后服务, salary=1000.0]
Employee [name=b, age=28, position=销售员, salary=2000.0]
Employee [name=c, age=18, position=售后服务, salary=1000.0]
*/
}
/**
* 13、将1000以内人民币的数字形式转换为人民币大写， 例如：调用18.5，将会返回字符串“壹拾捌圆伍角”;
*
*
*/
public class ConvertChar {
private static final char[] cnNumbers = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
private static final char[] units = { '厘', '分', '角', '圆', '拾', '佰' };
private boolean fullFormat = true;
public String format(double d) {
NumberFormat nf = new DecimalFormat("#.###");
double d1 = Math.floor(d);
if (d1 > 0.0 && d1 < 1000.0) {
String original = String.valueOf(nf.format(d));
return this.transform(original);
}
return "输入一个大于0小于999的数！";
}
public String format(Integer num) {
return this.transform(String.valueOf(num));
}
private String transform(String original) {
String integerPart = "";
String floatPart = "";
if (original.indexOf(".") > -1) {
int dotIndex = original.indexOf(".");
integerPart = original.substring(0, dotIndex);
floatPart = original.substring(dotIndex + 1);
} else {
integerPart = original;
}
StringBuffer sb = new StringBuffer();
// 整数部分
for (int i = 0; i < integerPart.length(); i++) {
int number = Integer.parseInt(String.valueOf(integerPart.charAt(i)));
sb.append(cnNumbers[number]);
if (fullFormat) {
sb.append(units[integerPart.length() + 2 - i]);
}
}
// 小数部分
if (floatPart.length() >= 1) {
for (int i = 0; i < floatPart.length(); i++) {
int number = Integer.parseInt(String.valueOf(floatPart.charAt(i)));
sb.append(cnNumbers[number]);
if (i < 3) {
sb.append(units[2 - i]);
}
}
} else if (fullFormat) {
sb.append('整');
}
return sb.toString();
}
public static void main(String[] args) {
ConvertChar char1 = new ConvertChar();
System.out.println("请输入一个大于0小于1000的数：");
Scanner scanner = new Scanner(System.in);
double d = scanner.nextDouble();
System.out.println(char1.format(d));
scanner.close();
}
}
