JAVA开发

JAVA开发

基础语法部分，仅包含基础数据结构与面向对象

JAVA DAY1 基础语法（12/9）

After-class Assignments

1.JDK JRE JVM

JDK :JAVA Development kit JAVA开发工具包，包含JRE JVM

JRE:JAVA Runtime Enviroment JAVA运行环境，包含JVM]

JVM:JAVA Virtual machine JVAV虚拟机，class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。

只有JVM还不能成class的执行，因为在翻译class时JVM需要调用解释所需要的库lib，其包含于JRE中

JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码，就可以在多种平台上不加修改地运行。

2.JAVA源文件名与类名一致

JAVA源文件名与类名一致是为了方便JAVA import时按路径查询，其中源文件名必须与该文件中class main一致，但可以存在其他class，javac时会将源文件中所有类均输出为.class文件

3.JAVA注释

注释可以用 // 来注释一行 ；可以用/* */来注释一段

note knowledge

1.JAVA架构

Mysql + radis →JAVA→HTML + JavaScripe + CSS

Javac HelloWorld.java（必须带.java）→ HelloWorld.class → Java HelloWorld（不用带后缀名）

框架（SSM）: SpringNWC + Spring + mybaits → Springboot → Springcloud

2.format用法+printf用法

3.为什么安装完jdk后不配置环境变量就能直接运行java,而不能运行javac

在安装jdk的时候jdk会自带一个jre(java运行环境)，还会单独安装一个jre，默认路径是和jdk在同级目录，而且会将这个jre/bin/java.exe拷贝一份到C:\Windows\System32\目录中，而这个目录在系统安装的时候就被配置到了环境变量中，所以能运行java。

不能运行javac是因为javac.exe是位于%JAVA_HOME%\bin目录下面，这个可执行文件没有被配置到环境变量PATH中;

unknow questions

1.ASCII码大小写，符号类型判断

img

a ~ z：97-122； A ~ Z：65-90 ； 0 ~ 9：48-57；

大小写相差32

2.数据类型陷阱：猜想为数据类型转换计算时丢失，数据类型最大最小值限制

3.format动态设定占位符格式

A daily test

1.Java SE和Java EE的区别

Java SE：standard edition 个人版java应用程序 J2SE 包含部分常用java运行库

Java EE：enterprise edition 企业版java应用程序 J2EE 包含大部分java运行库，常用于企业级应用开发

2.手动开发java程序的实现思路

提出需求→ 需求分析（需求碎片化）→逻辑分析（流程图呈现）→代码实现分析（面向对象 →包/类分割→变量定义/基本逻辑处理）→代码调试→需求匹配定义→代码优化→代码封装

创建java项目project→创建包package→创建类class

3.Java在软件体系下的定义模型

1575945000040

4.输入如下程序：（图略）

public class Aft_Work{
    public static void main (String[] args){
        /*String str="购物清单";
        int length=str.length();
        System.out.println(length);*/
        System.out.printf("%10s\n","购物清单");
        String str=String.format("%4s%6s%6s%4s","商品名称","购买数量","商品单价","金额");
        String str1=String.format("%4s%6d%12d%8d","鳄鱼夹克",1,1900,1900);
        String str2=String.format("%4s %6d%12d%8d","ipodMP4",2,400,800);
        System.out.println(str);
        System.out.println(str1);
        System.out.println(str2);
    }
}

JAVA基础语法DAY2(12/10)

note knowledge

1.变量及数据结构

变量；数据类型；数据结构

变量：在数据内容中开辟用于保存数据的空间（null无地址，未被实例化的对象不可用于equal判定；“”表示一个已被实例化的对象可以用于equal判定）

变量命名：首字母：字母，下划线以及$ ；不能与关键字重复

注：String对象均不能用于==判定

数据类型： 数值：整型int 非整型 double 非数值： char String

short：2字节 int：4字节 double：8字节

2.format用法

System.out.format("%-15s %5s %10s\n", "item","qty","price");
System.out.format("%-15s %5s %10s\n", "----","---","-----");		
System.out.println("123456789123456789123456789123456789123456789");
System.out.format("%-15.15s %5d %10.2f\n", "lalala",4,4.25);

format定义格式，- 表示左对齐，无符号表示右对齐

format各数据类型表示方法：

转换符 说明 转换符 说明
%s String %c char
%d int（dec） %x int(hex)
%o int(oct) %f float
%a Hex float %e 指数
%n \n %tx time
标志 说明 示例 结果
+ add symbols
- left justifying
0 add 0 front num
空格 blank
， divide into groups

其余后续补充；

3.JAVA运算符

舍掉小数取整:Math.floor(3.5)=3 四舍五入取整:Math.rint(3.5)=4
进位取整:Math.ceil(3.1)=4 取绝对值：Math.abs(-3.5)=3.5
取余数：A%B = 余数

算数>关系>逻辑

4.三目运算符逻辑规律

1.？后两表达式如果为相同类型，则输出该类型

2.一表达式如果为char/short/byte类型，另一表达式为int类常量（且该常量在另一表到时的取值范围内）则输出字符类型

3.若两个表达式类型不同且超出范围，则进行整体类型提升char→int（ASCII）后输出

After-class Assignments

1.基本数据类型

类型 型别 字节 取值范围
Byte 整型 8bit -2^7 ~ 2^7-1
short 整型 2Byte -2^15 ~ 2^15-1
int 整型 4Byte -2^31 ~ 2^31-1
long 整型 8Byte -2^63 ~ 2^63-1
float 浮点型 4Byte 3.402823e+38 ~ 1.401298e-45
double 浮点型 8Byte 1.797693e+308~ 4.9000000e-324
char 文本型 2Byte 0~2^16-1
boolean 布尔型 1Byte true/false

注：为什么String不是基本数据类型：因为String是一个基本类，且操作时是将string类进行封装处理，故调用时不可以改变内容，实际操作的为字符数组；

2.标识符命名规则

不与关键字重复，首字母可为字母，下划线以及$7

A daily test

1.java的基本数据类型

byte int（4byte) char(2byte) long(8byte)

double(8byte) short(2byte) boolean(1byte) float(4byte)

2.变量的定义步骤a

先声明后赋值（可同时）

3.java命名规则：不与关键字重复&&首字母可为字母，下划线和&&字母，下划线，数字和$

4.自动类型转换规则：由占字节符少的向高的转换（由小至大）

import java.util.Scanner;
public class Every_text{
    public static void main (String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.print("STB grade is:");
        int STB_grade = scanner.nextInt();
        System.out.print("java grade is:");
        int java_grade = scanner.nextInt();
        System.out.print("SQL grade is:");
        int SQL_grade = scanner.nextInt();//input some grade
        System.out.println("-------------------");
        System.out.println("STB\tJava\tSQL\t");
        System.out.printf("\n%d\t%d\t%d",STB_grade,java_grade,SQL_grade);
        System.out.println("\n------------------");
        if(SQL_grade>java_grade){
        	int subtract = SQL_grade - java_grade;
        	System.out.println("java between SQL grade different is:"+subtract);
        }// judge the SQL and java grade->this is SQL>java
        else{
            int subtract = java_grade - SQL_grade;
        	System.out.println("java between SQL grade different is:"+subtract);
        }//this is java>SQL
        int sum = SQL_grade + java_grade + STB_grade;//because all grade is int
        double avg = (double)sum/3;//type conversion
        System.out.printf("%s%.2f","the three project average is:",avg); 
    }    
}

JAVA基础语法DAY3(12/11)

note knowledge

1.关系运算符

！非>算数>比较&&与>||或；

2.三种基本逻辑

if(determin type){code section}

else{code section}

if ....else if...else... 嵌套if的用法（最后一个else不用加{}）

1576048918267

3.判断输入是否合法的示例代码（scanner判断及嵌套if）

package On_class1211A;
import java.util.Scanner;
public class On_class1211B {
public static void main(String[] args) {
	System.out.println("我行我素购物管理系统>客户信息管理>添加客户信息\n");
	System.out.println("请输入正确的用户名");
	//Scanner scanner = new Scanner(System.in);
    // scanner 对象引用应放在for循环里实现实时更新
	int num = 0;
	for(int i=0;i<3;i++){
	Scanner scanner = new Scanner(System.in);
	System.out.print("Please input your membership number ：");
	if(scanner.hasNextInt()){
		num = scanner.nextInt();
		if(num>=1000&&num<=9999){
			System.out.println("your membership number is："+num);
			break;
		}else{
			System.out.println("your vip_num is wrong");
			}
		}
	else
			System.out.println("you should input number");		
	}
	System.out.println("10 times is exhausted");
}

4.枚举的使用方法enum

设定初始enum

enum Color {RED, GREEN, BLUE;
enum Size {BIG, MIDDLE, SMALL;

for (Color c : Color.values()) {//建立Color的对象c
	System.out.println(c + " ordinal: " + c.ordinal());
}//.values返回实例数组，严格按照顺序
//.ordinal返回实例声明（初始化）时的次序，从0开始

Color green = Color.GREEN;//实例化GREEN对象
System.out.println("green name(): " + green.name());
//green name(): GREEN ;name()返回实例名
System.out.println("green getDeclaringClass(): " + green.getDeclaringClass());
//green getDeclaringClass(): class org.zp.javase.enumeration.EnumDemo$Color
//返回实例所属的enum类型
System.out.println("green hashCode(): " + green.hashCode());
System.out.println("green compareTo Color.GREEN: " + green.compareTo(Color.GREEN));
System.out.println("green equals Color.GREEN: " + green.equals(Color.GREEN));
System.out.println("green equals Size.MIDDLE: " + green.equals(Size.MIDDLE));
System.out.println("green equals 1: " + green.equals(1));
System.out.format("green == Color.BLUE: %b\n", green == Color.BLUE);

5.BigdecimalDemo的用法

public class BigdecimalDemo{
public static void mian(String[] args){
	System.out.println(2.0-1.1)//发现数据丢失
	BigDecimal a = new BigDecimal("2.0008");
	BigDecimal b = new BigDecimal("1.1");
    //如果直接是小数类型，double类型会限制其输出，导致精度丢失，可用 String str1 = String.valueOf(2.0008);转换为字符串格式
    BigDecimal result = a.subtract(b);
    //BigDecimal result = a.subtract(b).setScale(1.BigDecimal.ROUND_HALF_UP);
    result.setScale(1,BigDecimal.ROUND_HALF_UP);//四舍五入
    System.out.println("result");
}  
}

注：java中float和double主要用于工程计算或科学计算，不适用于精确计算，BigdecimalDemo

A daily test

1.java选择结构包括if和switch 其中if用于区间或多条件判断；switch用于选择结构判断；if与else if和else综合使用，switch与case和default综合使用

2.switch的条件表达式int char byte short enum string

JAVA基础语法DAY4(12/12)

note knowledge

1.字符数组ToCharArray()的用法

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	String input = scanner.next();
	for (char c : input.toCharArray()) {
//for循环里定义局部变量c，且为toCharArray处理，同样可用于数组的遍历，如 for(int c:array)
		System.out.println(c);
		if (Character.getType(c) == Character.OTHER_LETTER) {
			System.out.println("中文");
//判断是否为中文 Character.getType() == Character.OTHER_LETTER
			} else if (Character.isDigit(c)) {
				System.out.println("数字");
//判断是否为数字 Character.isDigit(boolean)
			} else if (Character.isLetter(c)) {
				System.out.println("英文字母");
//判断是否为英文字母 Character.isLetter()
			} else {
				System.out.println("其他字符");
		}
	}
}
}

2.==与equals的区别

==：两个引用（变量）在内存中是否指向同一对象，即是否指向同一地址，其中基本数据类型比较的是变量的值，而引用数据类型则比较指向地址

equals：分为Object equals和String/Date重写的equals ；未重写的未比较地址值，重写的为比较内容值

3.java调用方法返回多值（数组）

public class Array_Return {
    public static void main(String[] args) {
        int[] result = calclute(10,20,30);
        System.out.println("main方法接收到的返回值数组是： ");
        System.out.println(result);//地址值
        System.out.println(result[0]);
        System.out.println(result[1]);
    }
    public static int[] calclute(int a,int b,int c){
        int sum = a+b+c;
        int ave = sum/3;
// 用数组返回两个结果；
// 用静态数组
        int[] array = new int[] {sum,ave};
//用动态数组
/*      int[] array = new int[2];
        array[0] = sum;
        array[1] = ave;*/
        System.out.println("calclute方法内部数组的是：");
        System.out.println(array);//地址值;
        return array;
    }
}

4.java中全局变量的声明

java中全局变量声明在方法之外，分为静态变量和实例变量

public static int[] arrray = {1,2,3,4,5}

java中全局变量不能在类中先声明后赋值，也不能先在类中声明，在方法中赋值（静态变量可以先在类中声明，再在方法中赋值）

注：java全局变量不能在类中先声明后赋值的原因：类中无法直接对变量赋值，但可以加{}使之变为代码块执行

public class Text{
    static int a;
    int b;
    b=3;//报错，不能在类体中赋值
    int b = 3;//实例变量唯一可正确的全局变量表示方式
    public static void mian(String[] args){
        a=3;//正确，静态变量可以在类中声明后在方法中赋值
        b=3;//错误，实例变量不能在类中声明后在方法中赋值
    }
}

A daily test

1.Java循环结构简介

A.while循环

while (condition) { code section }

while用于已知判断条件，未知循环次数时

B.do while循环

do { code section } while (condition);

do while 用于需被执行一遍循环体后判断时（如菜单或用户名界面） 注：while后需加 ； ，因为其为代码块后单独的语句

C.for循环

for (int i = 0; i < sum.length; i++) { code section }

for用途最广泛，一般用于已知循环次数或循环条件单一时

JAVA基础语法DAY5(12/13)

note knowledge

1.SimpleDateFormat用法

2.Calendar的用法

public abstract class Calendar extends Objectimplements Serializable, Cloneable, Comparable<Calendar>

由其类的声明可知，Calendar被abstract修饰，为抽象类，无法通过new方式来实例化

Calendar rightNow = Calendar.getInstance();

int year = calendar.get(Calendar.YEAR);//获取年
int month = calendar.get(Calendar.MONTH) + 1;
// 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
int day = calendar.get(Calendar.DAY_OF_MONTH);// 获取日
int hour = calendar.get(Calendar.HOUR);
// int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示 
int minute = calendar.get(Calendar.MINUTE);// 获取分
int second = calendar.get(Calendar.SECOND);// 获取秒
int weekday = calendar.get(Calendar.DAY_OF_WEEK);// 星期，英语国家星期从星期日开始计算
System.out.println("现在是" + year + "年" + month + "月" + day + "日" + hour+ "时" + minute + "分" + second + "秒" + "星期" + weekday);

calendar.add(Calendar.YEAR,1);//当前年份加1，注意：此处calendar已被实例化为当前年份加一
int year = calendar.get(Calendar.YEAR);//获取年份等，与上面代码相同

判断是否为闰年的方法

public static boolean getYear(int year) {
	Calendar c = Calendar.getInstance();//创建对象c
	c.set(year, 2, 1);//设置为3月1日：月份为从零开始的数组
	c.add(Calendar.DAY_OF_MONTH, -1); 	//当前月份减一
    System.out.println(c.get(Calendar.DAY_OF_MONTH));//显示前一月份（2月份）的最后一天日期
	return c.get(Calendar.DAY_OF_MONTH) == 29;//判断是否为29.是则为闰年，不是则为平年
}

3.Java中静态代码块、代码块以及构造函数执行顺序详解

public class testOne extends TestTwo{
    //TestTwo为父类 testOne为子类
    public testOne(){
	//在输出语句前存在隐式的super是指向父类的指针
        System.out.println("子类构造方法");
    }
    {
        System.out.println("子类代码块");
    }
    static {
        System.out.println("子类静态代码块");
        //父类静态代码块执行后，执行子类的静态代码块
    }
    public static void main(String[] args) {
        new testOne();
        //主入口，首先执行的语句，创建子类对象，到子类的构造方法testOne()
    }
}
class  TestTwo{
    //一个类中静态代码最先执行，故当super指针指向此时，执行父类的静态代码块
    public TestTwo(){
        System.out.println("父类构造方法");
    }
    {
        System.out.println("父类代码块");
        //此处父类代码块实际上为父类构造代码块
        //反编译可知代码块执行优先于构造方法
    }
    static {
        System.out.println("父类静态代码块");
    }
    public static void find(){
        System.out.println("静态方法");
    }
}
//父类静态代码块——>子类静态代码块——>父类代码块——>父类构造方法——>子类代码块——>子类构造方法
/*summary：1.静态代码块是最优先执行的，且只会执行一次
2.调用子类的方法时会指向父类的构造方法—>父类构造方法优先级低于代码块->代码块优先级低于静态
3.静态代码块>main方法>构造代码块>构造方法*/

4.Java笔记之静态方法，非静态方法，静态变量，非静态变量四者之间的关系

静态方法： public static void Demo(Srting[] args){ code section }

调用静态方法： scanner.nextInt()；

非静态方法：public void Demo1(String[] args){ code section }

调用非静态方法：Scanner input = new Scanner()；//实例化类对象

input.nextInt();//通过对象访问非静态方法

静态变量：在类中定义，被整个类的方法所共享

非静态变量即为成员变量，需先创建类对象，使用类对象.变量名来访问

public class Test {
    String name = "Hello";//非静态变量
    static String hobby = "World";//静态变量 
    //在静态方法中调用静态变量和非静态变量
    public static void Demo() {
    	Test test1=new Test();//创建类对象
    	System.out.println(test1.name);//通过对象来实现在静态方法中调用非静态变量
    	System.out.println(hobby);
        //System.out.println(name);//会报错
        test1.Demo1();//使用创建的类对象来访问非静态方法
   	}
    public void Demo1(){
		System.out.println(name);
    	System.out.println(hobby);//非静态方法可直接访问同类的所有变量
        Test.Demo();//非静态方法可直接调用静态方法
    }
}/*summary:1.所有的访问非静态变量的均需创建类对象   
2.所有的访问静态变量可直接通过类访问
3.非静态方法可访问所有的全局变量（静态变量与实例变量）
4.静态方法可直接访问静态变量，需通过实例化对象访问非静态变量
变量：静态->所有本类方法；非静态->非静态方法/静态创对象
方法：静态->静态对象，非静态对象创方法
非静态方法->所有全局变量

unsolved question

1.SimpleDateFormat用法

2.Java集合的用法

JAVA基础语法DAY6(12/14)

note knowledge

1.数组进阶

数组之间的赋值：实际上是将两个数组变量引用到同一个内存空间当中

数组之间的完全赋值： int[] num = Arrays.copyOf(old,old.length);

Java中声明数组时的[]被预定义为检查数组边界，无法像C++一样int a[100]; 来声明数组

整数值数组排序 Arrays.sort(array);

Arrays常用API
API instruction
copyOf static type copyOf（type[] a，int length）
toString static String toString（type[] a）
binarySearch static int binarySearch（type[] a，type v）focus: arrays should have been sorting

static void arraycopy（Object from，int fromIndex，Object to，int toIndex，int count）—jdk1.1

将第一个数组from中的元素拷贝到第二个数组to中

from：任意类型数组

formIndex：原始数组from中待拷贝元素的起始下标

to：与from同类型的数组

toIndex：目标数组to放置拷贝元素的起始下标

count：拷贝的元素数量

二维数组

java中实际上没有二维数组，被解释为数组的数组，引用时通过外围数组去引用内部数组

int[][] new_array = { {1,2,3,4},{11,22,33,44},{111,222,333,444} };
	for (int[] row : new_array) {
		for (int i : row) {
			System.out.print(i+"\t");
		}
	//System.out.println();
	//System.out.print(row+"\t");//输出地址
	}
	System.out.println();
	System.out.println(Arrays.deepToString(new_array));//以字符串形式输出二维数组
	int[] temp = new_array[2];
	new_array[2] = new_array[1];
	new_array[1] = temp;
	System.out.println(Arrays.deepToString(new_array));

JAVA基础语法DAY8(12/16)

note knowledge

1.construct object

parameter constructors

class Primary_Main{
    public static void main(String[] args){
        Construct_Demo1 MrWu = new Construct_Demo1("Mr.Wu",3000);
        System.out.println("this is test name"+MrWu.getName()+"this is test salary"+MrWu.getSalary());
        Construct_Demo2 John = new Construct_Demo2("John",2000,"test");
        System.out.println("this is test name"+John.getName()+"this is test salary"+John.getSalary()+"this is third test"+John.getTest());
    }
}
class Construct_Demo1{
    private String name;
    private double salary;
    private test = test;
    public Construct_Demo1(String name,double salary){//construction method is same as class name;
        this.name = name;
        this.salary = salary;
        System.out.println("this is construct function");
    }
    public Construct_Demo2(String name,double salary,String test){
        this(name,salary);
        //recursive construction invocation->call other construction,unuse itself or completely overloaded
        this.test = test
    }
    public String getName(){
        return name;
        //this name is that construct function name->return this.name ,thus object.construct isnot send actual parameter;
    }
    public double getSalary(){
        return salary;
    }
    public String getTest(){
        return test;
    }
}

2.String 和各类型之间的转换

String s = "169";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );

A daily test

1.int[] array_A = new int[num];//num is defined variable int[] array = {1,2,3,4}

2.int array_length = array.length ->getLength

3.two-dimension array initalize ： int[ ] [ ] array_B = new int[3] [ ];``//array_B[i] = new int[1]；

int[ ] [ ] array_B = new int[3] [1]； int [ ] [ ] array_B = { {1,1},{2,2},{3,3},{4,4} };

4.int[ ] [ ] array_C = new int[3] [4]； for(int[ ] row:array_C){

for(int i:row) { System.out.println("i+"\t")； } }

5.different array element initial value is: int -> 0；double -> 0.0；char -> □ ；boolean -> false；String -> null；

JAVA基础语法DAY9(12/17)

1.OOP

计算机编程领域理解和抽象客观事物的一种方式

事务的特征--属性 ；事务的行为--方法；

class是object的模板，class的basic value -> establish object

first establish class (properties and methods)-> then object (properties and methods) -> call object ->finsh basic funticon

定义为private的方法只能在该类中被调用->一般情况下其形参为其他public方法（get）传递的参数值，故其形参一般不必声明为private

2.构造方法

没有在构造方法中初始化字段时，引用类型的字段默认是null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false：，也可直接初始化赋值；

当初始化字段 和 在 构造方法对字段进行初始化 同时存在时，由于构造函数后运行，因此赋予构造方法的值

子类无法重写和继承父类的构造方法，只能调用并赋值。

3.重载overloaded

方法名相同，但各自参数不用的 同名方法 称为方法的重载，方法的返回值类型通常是相同的；

举个栗子，String类提供了多个重载方法indexOf()，可以查找子串：

  • int indexOf(int ch)：根据字符的Unicode码查找；
  • int indexOf(String str)：根据字符串查找；
  • int indexOf(int ch, int fromIndex)：根据字符查找，但指定起始位置；
  • int indexOf(String str, int fromIndex)根据字符串查找，但指定起始位置。

4.继承inherit

Java使用extends关键字来实现继承，继承时，已父类（超类、基类）的属性不用再次重复，子类也可称为扩展类；

class subclass extends superclass //subclass inherit superclass

注：所有父类即初始类，共同默认继承于Object类

一个类有且只有一个父类，而一个父类可被多个子类继承

子类无法访问父类的private属性，protected属性可以被子类访问，父类无法访问子类的所有属性

super（）的用处：

由于构造函数一旦含参设置，编译器就不再默认设置未含参构造方法，故若父类不存在未含参构造方法时 -> 子类默认调用父类时添加的super（）无法找到父类的未含参构造方法，因此出错

应该手动添加super（XX,XX)含参构造方法，或在父类中设定无参构造方法

注：thus conclude：子类不会继承父类的任何构造方法，即在父类构造方法中的值不会赋值至子类中

class Person {
    protected String name;
    protected int age;
    public Person(){
    	System.out.println("super class");
    }
    public Person(String name, int age) {
        this.name = "aa";
        this.age = 12;
        System.out.println("super class have parameter");
    }
}

class Student extends Person {
    protected int score;
    public Student(){
        //super(); call superclass construct method which dont have parameters
    	System.out.println("subclass"+name+age);
    }//superclass /n subclass+null+0 
    public Student(String name, int age, int score) {
    	super(name, age);// super class have parameter
        this.score = score;
        System.out.println("subclass"+name+age);//these are main method give parameters
    }
}

upcasting(向上转型)：new subclass - > superclass

Superclass instance_name = new Subclass();//subclass inherit superclass ,thus it have all superclass methods and properties

JAVA基础语法DAY10(12/18)

1.inherit(continued)

downcasting(向下转型)

public class test2 {
	public static void main(String[] args) {
		// supercasting Apple instantiation -> Fruit quoted
		Fruit fruit = new Apple();
		fruit.show();// ->only can method which superclass haved can be uesed;
		/**
		 * downcasting this.fruit is Apple instantiation but quote by Fruit So
		 * if you want to use this.fruit to interview method which Fruit dont
		 * have, you should return it quoted to Apple mean subclass quoted
		 */
		((Apple) fruit).test();//fruit.test(); is wrong
		Orange orange = (Orange) fruit;//wrong 
		run(new Fruit());
	    run(new Apple());
	    run(new Orange());//not necessary to overloaded static run(Fruit fruit)
	}

	public static void run(Fruit fruit) {
		fruit.show();
	}
}

class Fruit {
	public void show() {
		System.out.println("this is fruit");
	}
}

class Apple extends Fruit {
	public void show() {
		System.out.println("this is apple");
	}

	public void test() {
		System.out.println("this is test");
	}
}

class Orange extends Fruit {
	public void show() {
		System.out.println("this is a Orange");
	}

	public void test() {
		System.out.println("i am a Orange");
	}
}

class Student extends Person {
    // student inherit Person and it has Book class
    protected Book book;
    protected int score;
}

2.Polymorphic(多态)

public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.run(); // 应该打印Person.run还是Student.run?//Student.run
    }
}

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

class Student extends Person {
    @Override//覆写，当两种方法完全一致（返回值类型和含参类型及方法名）时称为多态覆写
    public void run() {
        System.out.println("Student.run");
    }
}

Summary：Java调用时是基于实际的动态调用，而非变量的声明类型

子类的方法返回值类型需要小于父类被覆写方法返回值类型 superclass return Object -> subclass return String

子类覆写方法访问修饰符 > 父类被覆写方法访问修饰符（private不能被覆写）

如果在子类的覆写方法中，需要调用父类的被覆写的方法（即我调我）：return super.method()+"AAA";

如果不希望某个类被覆写，可以将该方法标记为final，并且，用final修饰的类也不允许继承

final修饰的字段也不可被重新赋值，但构造方法仍然可以对其赋值

JAVA基础语法DAY11(12/19)

1.Abstract（抽象）and Interface(接口)

Abstract用于被多态覆写的父类（其本身不实现任何方法，只为被覆写），其无须代码块{}；//方法被abstract，其所属类也必须被abstract，其将会导致该抽象类无法被实例化；

抽象类的用处：用于实现不确定->明确类型但各个子类不同 的属性，为了方便子类的重用 ->

如果一个抽象类没有字段，所有方法全是抽象方法，则其称为接口类

abstract class interface
inherit only one subclass can be inheritedb by many
field define instantance can't define instantance
abstract method define abstract method define abstract method
non-abstract method non-abstract method default method

接口类中变量通常只有static与final修饰，接口可以用extend实现多重接口继承

接口interface中成员属性默认为public static final 修饰，方法属性默认为public abstract

package day4;
import java.util.Scanner;
public class test3 {
	public static void main(String[] args) {
		System.out.println("输入英文名");
		Scanner scanner = new Scanner(System.in);
		String classname = scanner.nextLine();
        //根据Factory类中getInstance方法可得，这里为向上转型
		Thing f = Factory.getInstance(classname);
        //Fruit c = Factory.getInstance(classname);向上转型接口的引用只能访问接口的方法
		f.eat();
        //根据输入向下转型（f为向上转型的，所以这里可以向下），访问父类中没有，而子类中有的test1方法
		if (classname.equals("apple")) {
			((Apple) f).test1();
		} else {
			((Orange) f).test1();
		}
		scanner.close();
	}
}
interface Fruit {
    //接口一旦被implement，其中所有的方法必须被override
	void eat();
}
abstract class Thing implements Fruit {
	protected String color = "黄色";
	protected String age = "未过期";
	public Thing(String color, String age) {
		this.color = color;
		this.age = age;
		System.out.println(this.color + this.age);
	}
	public Thing() {
	}
    //抽象测试函数
	abstract void Abstract_test();
    //这里为接口类的重写，注：必须有接口中的所有方法，但子类可以不必有父类（抽象类）的所有方法
	@Override
	public void eat() {
		System.out.println("这是父类的吃吃吃");
	}
}
class Apple extends Thing implements Fruit {
    //显式调用父类的含参构造函数
	public Apple(String color, String age) {
		super(color, age);
	}
	public Apple() {
		// TODO Auto-generated constructor stub
        //显式调用父类的无参构造函数
		super();
	}
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃苹果");
	}
	public void test1() {
		System.out.println("这是苹果的测试,父类中无此");
	}
	@Override
    //继承抽象类
	void Abstract_test() {
		// TODO Auto-generated method stub
		System.out.println("这是苹果的抽象方法");
	}
}
class Orange extends Thing implements Fruit {
	  //显式调用父类的含参构造函数
	public Orange(String color, String age) {
		// TODO Auto-generated constructor stub   
		super(color, age);
	}
	public Orange() {
		// TODO Auto-generated constructor stub
        //显式调用父类的无参构造函数
		super();
	}
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃橘子");
	}
	public void test1() {
		System.out.println("这是橘子的测试，父类中无此");
	}
	@Override
	void Abstract_test() {
		// TODO Auto-generated method stub
		System.out.println("这是橘子的抽象方法");
	}
}
class Factory {
	public static Thing getInstance(String nameclass) {
		if ("apple".equals(nameclass)) {
			return new Apple("红色", "未过期");
		} else if ("orange".equalsIgnoreCase(nameclass)) {
			return new Orange("黄色", "过期了");
		} else {
			return null;
		}
	}
}
/**summary：父类可以继承接口：即父类的父类为抽象类，可以多重向上继承；
接口中的方法与抽象方法必须包含于其每个子类中，访问时可以直接创建子类的new空间，引用类型为其父类，如果引用为接口类，则其只能访问接口类中存在的方法（即爷爷类），可以向下继承为父类乃至本类

JAVA基础语法DAY12(12/20)

1.static field

static field不能用于构造方法初始化，其能被所有的实例化对象都能访问并且修改它。

non recommend使用 instance object.static field 的方法 -> 构造函数不能访问静态字段，之所以可以用，是因为编译器会将其自动compile为class.static field的方式去访问，recommend使用class.static field的方式来访问静态字段

2.static method

due to static method属于该class，不属于instance variable，因此在静态方法内部，无法使用this，也无法访问instance field(mean construct method)，只能访问static field；

attention：interface method 默认修饰符为public abstract

故其成员变量默认修饰符为public static final int a;->（be equivalent to） int a;

class Person{
    //Date 日期类
    private Date birthDate;
    //创建static对象，防止重复调用空间
    private static Date startDate,endDate;
    //代码块，提供static，一般存放只初始化一次的操作
    static{
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }
     
    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
    public Test() {
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new MyClass();
    }
} 
class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
} 
class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
    public MyClass() {
        System.out.println("myclass constructor");
    }
}
/**Test类static构造体：test static -> main 入口new Myclass ->加载Myclass -> myclass static -> Test类变量初始化 ->new Person ->加载Person -> person static -> person test ->Test构造函数 -> test construct -> MyClass类变量初始化 -> new Person("MyClass") -> person MyClass -> MyClass构造函数 -> mycalss constructor
/**summary:加载 ->static代码体 -> 变量初始化 -> 构造函数(调用过程中已被加载过，且对象未变化的{}代码体只执行一次)

3.只允许创建一个类对象的单例模式

public class Singleton_Pat{
    public static void main(String[] args){
        //Singleton singleton = new singelton;
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        SingletonDemo singletondemo = SingletonDemo.getInstance();
        SingletonDemo singletondemo1 = SingletonDemo.getIntsance();
        System.out.println(singleton == singleton1);
        System.out.println(singletondemo1 == singletondemo);
    }
    
}
class Singleton{
    private static Singleton singleton = new Singleton();
    private Singleton(){}
    public static final Singleton getInstance(){
        return singleton;
    }
}
class SingletonDemo{
    private static SingletonDemo singleton;
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        if(singleton == null){
            singleton = new SingletonDemo();
        }
        return singleton;
    }
}

JAVA基础语法DAY13(12/21)

1.接口和抽象类的区别

  1. 抽象类要被子类继承，接口类要被子类实现
  2. 抽象类可以包含子类中没有的方法，而接口类所有方法均要被子类实现，且均无方法体
  3. 接口类没有构造方法，不能有构造代码块以及静态代码块，只能声明静态常量。抽象类就是特殊的父类，均可以有
  4. 抽象类可以有具体的方法和属性，接口只能有方法声明->1.8以后可以有default方法体
  5. 均不能被实例化，接口实现为implement，抽象继承为extends
  6. 一个子类只能继承一个直接父类（抽象类），但可以实现多个接口类
  7. 接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。
  8. 接口只能继承接口，不能实现接口，接口可以多继承，类实现接口->最终实现了Java的多重继承

2.final的注意事项

  1. final使用时必须初始化，一般与static final联合使用，使用时变量一般为大写。
  2. final修饰对象时，对象地址不能变，但对象属性可以变化（get/set）
  3. final修饰方法时该方法不可被覆写，final修饰类时该类不可被继承，final修饰变量时该变量不可被赋值

3.包装与拆箱

1.Integer -> int 自动装箱，自动拆箱，可以互相转换，Integer可以放置null，也可称之为引用类型，后期多用于开发中，integer必须要赋初值，可以toString

Integer a = new Integer(100) //自动装箱
int b = a;//自动拆箱
String  str = "123456"
new Integer(str);//匿名对象（没有变量名）创建出来就是垃圾
int num = Integer.parseInt(str);//常用方法使用static，通过class.method来访问
Integer valueOf = Integer.valueOf("123456")//和5行作用相同

2.当一个包装类型与基本类型进行比较时，包装类型会自动拆箱为基本类型，从而比较基本类型内容

int -> Integer char -> Character byte -> Byte boolean -> Boolean short -> Short

long -> Long float -> Float double ->Double

public class Test1{
    public static void main(String[] args){
        char ch = 48;//特例：char '\u0000'~'\uffff' 65535
        Character cha = new Character('aa');
        char ch2 = cha; //自动拆装箱           
    }
}

2.包装类型在声明变量时自动赋值为null（类变量初始化）

3.成员变量 = 实例变量 =对象变量：在类中声明的，作用域为整个类，在创建对象时初始化；类变量 = 静态成员变量，在类加载时初始化（与静态代码块优先级相同），所有的形参都是局部变量

4.类一定要声明为public才可执行 -> 显式定义的public为main函数入口，但默认class访问修饰符均为public

5.先声明对象，为对象分配内存空间，对对象初始化，才能使用对象

6.子类访问权限大于等于父类：

class X{
    protected String toString(){
        return super.toString();
    }
}//编译报错，重写了String类型，因此需要将protected修改为public

7.一个子类有且只有一个直接父类，但可以有多个父类->extends / implement

4.简述什么事面向对象三大特性，并简述

  1. 封装：隐藏对象的属性和实现细节，给外部实现方法方式
  2. 继承：子类继承父类，共享父类的属性和方法，并且可以扩展
  3. 多态：父类的变量指向子类的对象（存疑）

5.简述重载重写得到条件

重载：在同一类型中，同名，不同参，与返回值类型无关

重写：在不同类型存在子父类关系中，同名，同参，同返回值类型

JAVA基础语法DAY14(12/23)

1.含继承关系的java面向对象执行顺序详解

类加载，验证，准备，解析，初始化

1.父类静态代码块->子类静态代码块->父类属性值/父类代码块->父类构造方法->子类属性值/子类代码块->子类构造方法

注：从上而下按顺序，并且遇类先加载（即new object）

2.静态资源在类的初始化中只执行一次（重点）即一条语句只执行一次static(包含static new)

3.非静态资源会随着对象的对象的创建而初始化，每创建一次对象，执行一次初始化

class SingleTon {  
    //执行加载时，singleTon进行显式初始化，这时会调用构造函数，之后静态变量初始化，再之后才是静态代码块
    private static SingleTon singleTon = new SingleTon();  
    public static int count1;  
    public static int count2 = 1;  
  
    private SingleTon() {  
        count1++;  
        count2++;  
    }  
  
    public static SingleTon getInstance() {  
        return singleTon;  
    }  
}  
  
public class Test {  
    public static void main(String[] args) {  
        SingleTon singleTon = SingleTon.getInstance();  
        System.out.println("count1=" + singleTon.count1);  
        System.out.println("count2=" + singleTon.count2);  
    }  
}

2.类的初始化详解

主动引用：创建实例/访问类的静态变量（除常量）/访问类的静态方法/初始化一个类

被动引用：子类调用父类的静态变量，子类不会被初始化/通过数组引用类/访问类的常量

3.进制转换

public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.toString(100)); // "100",表示为10进制
        System.out.println(Integer.toString(100, 36)); // "2s",表示为36进制
        System.out.println(Integer.toHexString(100)); // "64",表示为16进制
        System.out.println(Integer.toOctalString(100)); // "144",表示为8进制
        System.out.println(Integer.toBinaryString(100)); // "1100100",表示为2进制
    }
}

所有的包装类都继承自Number方法

Number num = new Integer(999);
// 获取byte, int, long, float, double:
byte b = num.byteValue();
int n = num.intValue();
long ln = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();

4.枚举JavaBean属性

import java.beans.*;
public class Test3 {
	public static void main(String[] args) throws Exception {
		BeanInfo info = Introspector.getBeanInfo(Person.class);
		for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
			System.out.println(pd.getName());
			System.out.println("  " + pd.getReadMethod());
			System.out.println("  " + pd.getWriteMethod());
		}
	}
}
/**age
  public int day1.Person.getAge()
  public void day1.Person.setAge(int)
class
  public final native java.lang.Class java.lang.Object.getClass()
  null
name
  public java.lang.String day1.Person.getName()
  public void day1.Person.setName(java.lang.String)
**/
class Person {
	private String name;
	private int age;

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

5.Java同名变量调用，调用的是父类变量的解析：

Java具有多态性，声明父类Fu，指向子类Zi，相当于一个向上转型，这里的Zi是由Fu实例化出来的，成员变量不具有多态性，直接访问为指向父类的成员变量值

6.enum补充解析

  1. enum定义的类型就是class，特点为：enum总是继承自java.lang.Enum，且无法被继承
  2. 只能定义实例，无法new创建
  3. 可以将enum用于switch语句

7.异常简析

从继承关系可知：Throwable是异常体系的根，它继承自Object。Throwable有两个体系：Error和Exception，Error表示严重的错误，程序对此一般无能为力，例如：

  • OutOfMemoryError：内存耗尽
  • NoClassDefFoundError：无法加载某个Class
  • StackOverflowError：栈溢出

而Exception则是运行时的错误，它可以被捕获并处理。

某些异常是应用程序逻辑处理的一部分，应该捕获并处理。例如：

  • NumberFormatException：数值类型的格式错误
  • FileNotFoundException：未找到文件
  • SocketException：读取网络失败

还有一些异常是程序逻辑编写不对造成的，应该修复程序本身。例如：

  • NullPointerException：对某个null的对象调用方法或字段
  • IndexOutOfBoundsException：数组索引越界

Exception又分为两大类：

  1. RuntimeException以及它的子类；
  2. 非RuntimeException（包括IOException、ReflectiveOperationException等等）

Java规定：

  • 必须捕获的异常，包括Exception及其子类，但不包括RuntimeException及其子类，这种类型的异常称为Checked Exception。
  • 不需要捕获的异常，包括Error及其子类，RuntimeException及其子类。

8.反射简析(difficult)

如果获取了这个class的实例，那么就可以通过JVM内置的原理通过API实现对这个class的所有信息包括类名，包名，父类，所有方法、字段实现的接口等

Integer n = new Integer(123);
boolean b1 = n instanceof Integer;//true
boolean b2 = n instanceof Number;//true
boolean b3 = n.getClass() == Integer.class;//true
boolean b4 = n.getClass() == Number.class;//false

public static void main(String[] args) {
        printClassInfo("".getClass());
        printClassInfo(Runnable.class);
        printClassInfo(java.time.Month.class);
        printClassInfo(String[].class);
        printClassInfo(int.class);
    }

    static void printClassInfo(Class cls) {
        System.out.println("Class name: " + cls.getName());//java.lang.String
        System.out.println("Simple name: " + cls.getSimpleName());//String
        if (cls.getPackage() != null) {
            System.out.println("Package name: " + cls.getPackage().getName());
        }
        System.out.println("is interface: " + cls.isInterface());
        System.out.println("is enum: " + cls.isEnum());
        System.out.println("is array: " + cls.isArray());
        System.out.println("is primitive: " + cls.isPrimitive());
    }

动态加载：直到程序执行至该类处时，才去加载该类，而非预加载或预编译

import java.lang.reflect.Field;
public class Reflect{
    public static void main(String[] args) throws Exception{
    ReflectDemo c = new ReflectDemo();
    System.out.println(c.getReflectDemo());
    Class p = c.getClass();//acquire Class 
    Field f = p.getDeclaredField("name");// acquire Field instance
    f.setAccessible(true);// IllegalAccessException,this is certificate,but still have oppounity to conflict with SecurityManager
    f.set(c,"cat");//catch and set to replace
    System.out.println(c.getRecflectDemo);
    }
}
class ReflectDemo{
    private String name = "dog";
    public ReflectDemo(){}
    public ReflectDemo(String dog){
        this.dog = dog;
    }
    public String getReflectDemo(){
        return this.name;
    }
}
  • Method getMethod(name, Class...)：获取某个public的Method（包括父类）
  • Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
  • Method[] getMethods()：获取所有public的Method（包括父类）
  • Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）

JAVA基础语法DAY15(12/24)

1.面向对象间类的基本关系

  • USES-A：依赖关系，具有偶然类

2.杂记

1.方法中的局部变量在方法被调用加载时开始入栈时创建，方法入栈创建栈帧包括局部变量表操作数栈，局部变量表存放局部变量，并非在执行该方法时被创建

2.重载是编译时多态，重写是运行时多态（编译看左边，运行看右边）

3.protected父类方法子类重写时，访问权限应该大于等于protected

JAVA基础语法DAY16(12/25)

1.Number类API

class Numberclass{
    public static void main(String[] args){
        Integer x = 5;
        System.out.println(x.byteValue());
        System.out.println(x.doubleValue());
        //xxxValue();
        System.out.println(x.compareTo(3));//1
        System.out.println(x.compareTo(5))//0 -1
        
    }
}

Math.celi(100.1);//101 Math.floor(100.9); //100

Math.ceil(-90.8); //-90 Math.floor(-90.8); //91

method description
rint() 向接近整数取整
round() Math.floor(x+0.5) 四舍五入，负数五舍六入

Number自动装箱过程是调用包装器的valueOf实现的，拆箱过程是调用包装器的xxxValue方法实现的；

2.Object类API

1.native关键字标识：表示由C/C++程序编译后生成的dll文件，Java加载本地dll文件后，通过本地方法调用dll函数

posted @ 2020-12-04 11:39  WheelCode  阅读(265)  评论(0)    收藏  举报