01BASIC_02OPP

===============================================================================================



for(:){
String str="asdga";
for(char s:str){ //char 指的是str的元素的类型
System.out.println(s);
}
int[] arr ={1,2,3,5};
for(int t:arr){//for(int i=0;i<arr.length;i++){}  //int指的是元素的类型
System.out.println(t);
}








for();{}


能.什么要看引用类型
重写看对象
===============================================================================================
置换算法：  a=5；b=3
1，使用中间值；
c=a; //c=5;
a=b; //a=3;
b=c; //b=5;
a=3;b=5;


2不使用中间值
a=a+b //a=8,b=3;
b=a-b; //a=8,b=5;
a=a-b; //a=3;
a=3;b=5;




命名可以用_和$
int $_$ 正确


输入（5+7+“heloo”+5+7 ） 编译为12hello57
因为字符串前面求和，字符串后面为拼接。java规则


1KB = 1024B
1B = 8Bit位


long a = 10000000000000L  一定要加L或l结尾


long a = 10000000000*2*10L 


long b = 10000000000*3*10l 溢出，十亿乘3超过20亿，溢出。溢出*10l
建议：写在第一个数字之后如：10000000000L*3*10;s


long a = 10000*365*24*299792458溢出。
long a = 10000*365*24*299792458L 正常。


System.currentTimeMillis() 返回1970年1月1日00：00到当前的毫秒数


int a = 10000000000  //编译错误（直接量超范围）


int a = 1000000000*10  //溢出（运算时超范围）


dataTypeDemo------------驼封命名法
DateTypeDemo------------帕斯卡命名法（如类名 class DateTypeDemo）




float f1 = 3.14 编译错误。应该写3.14f
默认的浮点型是double


舍入误差：
2进制无法精确表示1/10.即0.1如同十进制的1/3


double a =3.0;
double b =2.9;
println(a-b):  //0.100000000000000009---0.1


double a=6.0;
double b=4.9;
print(a-b);  //1.099999999996---1.1
   0.00000000000000004


财务ERP  --------不能用double
精确运算场合不能使用double和folat
用BigDecimal  如BigInteger一样


int c=2147483647; //int的最大值
c= c+1; //在c本身基础之上增1；
print(c) ;//溢出为-2147483648


double a =3.14159
float b= 3.14159 //错误。需要加F或 f因为浮点型默认都算double






字符char是表现形式，实质是其对应的码int（0-65535之间，也就是unicode的范围，世界通用的定长字符集，所有字符都是16位的）


ASCII：
'A'--65 'a'---97  '0' ----48  '2'-----50
char c1 = 'ab' //错误，只能一个字符
char c2 = 65; //输出A 
char print(2+2); //4
char print(2+'2'); //2+50=52;
char c1 = '   //错误，无结尾
';  //回车也是字符。错误，无开头


回车，tab---------控制字符---------需要转义
'\n' 表示回车
'\r' 表示换行符号
'\\' 反斜杠
'\'' 单引号


----------------------------------------------------
char c = ' '; //正确。空格的unicode码
char c = ''; //错误，必须有字符；
char c2 = '5' //5的码
char c = 97；  //正确，数值必须在0-65535之间。97是a的码
（‘2’+‘2’）   //输出100，‘2‘的码是int类型的，为50；


----------------------------------------------------------------
int a =5;
long b =a;
int c=(int)b; //强制转换，大转小。有可能溢出或丢失精度


-------------------------------------
2规则：
2.1 整数直接量可以直接赋值给byte,short,char,但不能超范围
2.2byte，short，char型变量参与运算时，先一律转为int再运算；
如：
byte b1 =5;
byte b2 =6;
byte b3 = b1+b2; //错误，
byte b3 = (byte)b1 + b2; //错误 转成了int，b2还是int类型
byte b3 = (byte)(b1+b2); //正确；




---------------------------------------
Day03 运算：
% 大除小需要运算，如8/2
但小除大，如2/8. 结果都是小数，不到1，因此商就是0.模则为大的数本身
如2/8的商是0，0乘8等于0，2只能除0，所以模的结果就是2；
5%2  //1，因为商2，余1；
8%2  //0， 商4，余0；
2%8  //2，商0余2；
8.456%2 //0.456.了解即可。




----------------------------------------------------
int a=10;b =20;
int c1 = a++;
int c2 = ++b;
//输出结果：a=11；b=21;c1=10,c2=31


---------------------------------------------------------
逻辑与或非


&& || 两个则表示短路，即前面的判断出结果后面的条件则不计算了
也可以用单个：&  | 则表示无论如何后面的结果都走一遍。


int a=5,b=10,c=5;


boolean b4 = a<b || a++>2;
print(b4); //true;
print(a); //5,发生短路了。即a<b为true，逻辑或中有true则全true，后面的a++>2不走。如果改成单个的 | 则a的输出变成6，因为走了一遍了；


----------------------------------------------------------
！！！！！！！！！！！！！！！！！！！！
常见面试题目：
short s1 =5;
s1= s1+10;  //只要参与运算，一律都算int。编译错误，大的int变成short，必须强转
//修改：s1=(int)(s1+10);
s1+=10；  //正确，因为扩展赋值运算自动强转；




！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！


print(10+20+""+30); //输出字符串3030 前面加法，字符串后面拼接
print(10+20+30+""); //输出字符串60;
print(""+10+20+30); //输出字符串102030;


三目/条件运算符：
1）语法：
boolean?数1：数2；
2）执行过程：
计算boolean的值；如果为true，执行数1，若为false，执行数2；




可以嵌套使用
int a=-3;
String r=a>0 ? "正数" : (a==0 ? "0" : "负数" );
print(r); //结果为负数；




4.break:跳出循环,剩下的次数不执行，只是跳出当前循环
  continue:跳过循环体中剩余语句而进入下一次循环，比如当前判断下面还有语句也不走了


---------------------------------------------------------------------------------
=================================================================================
Day03
分支结构：




满足就干事，不满足就不干事————————if
满足就干事，不满足就干另一件事情——————if else






1）ABCD四个档，只有可能走其中之一
2）若没有最后的else，则abcd 并非必走其中之一
3）若有最后的else，则abcd必走其中之一


int score=45;
if(score>=90){A}
else(score>=80){B}
else(score>=60){C}
else{不及格}


switch...case多条路
优点：效率高/结构清晰
缺点：整数/相等




int num=3;
switch(num){  //byte,short,int,char 只能用整型；
case 1:
System.out.println("显示全部记录");
break;
case 2: //以此为入口；
System.out.println("显示查询");
break; //跳出switch  //break如果不用，则入口即之下的都会执行。
case 3:
System.out.println("显示其他");
break: 
default: //只要上面没匹配就走默认的。可以放在任意位置。
System.out.println("输入错误"); 
break;//default放最上面一定要加break；放下方不需要；
}




5个经典案例：
age年龄判断程序
LeapYear闰年判断程序
Cashier收银程序
ScoreLevel成绩等级判断程序
CommandBySwitch命令解析程序
======================================================================
Day04:
循环结构 while    do...while
循环3要素：


循环结构：
1，while结构： while(判断条件boolean){} //当满足判断条件，即判断条件为true的时候就一直循环，直到false才结束；有可能一次也不执行，就是当判断结果为false的时候。
2，do...while结构  //先执行一次，再判断是否为true，是则继续，false则跳出。
3，for结构




笔记:
1.循环:反复执行一段相同或相似的代码
2.循环三要素:
  1)循环变量的初始化
  2)循环的条件(以循环变量为基础)
  3)循环变量的改变(向着循环的结束变)
  循环变量:在循环过程中所反复改变的那个量
3.循环结构:
  1)while:先判断后执行，有可能一次都不执行
  2)do...while:先执行后判断，至少执行一次
               第1要素与第3要素相同时，首选
  3)for:应用率最高，固定次数循环
4.break:跳出循环
  continue:跳过循环体中剩余语句而进入下一次循环


三要素
1，循环变量的初始化
2，循环的条件（以


接收用户输入
int guess = scan.nextInt();


for(int i=0,j=6;i<=6;i+=2,j-=2)
条件i<=6必须用；不能， 如果多个条件可以用&&


break 常与if用


======================================================================
Day05:
o  -------------char--字符-------- 编码0
char:字符型，2个字节，必须放在单引号中，有且仅有一个
char c1 = '女';
"0"-------------------int/long/----------字符串




System.Arraycopy(src,srcIndex,desti,destIndex,length)
e.g: arr = Arrays.copyOf(arr,arr.length+1);


(
import java.util.Arrays;
Arrays.copyOf(original,newlen) //短截取，长用null或0填充
)




Arrays.sort(arr)


——————————————————————————————————————————————————————


回顾:
1.循环:反复执行一段相同或相似的代码
2.循环三要素:
  1)循环变量的初始化
  2)循环的条件
  3)循环变量的改变
  循环变量:在循环过程中所改变的那个量
3.循环结构:
  1)while:先判断后执行，有可能一次都不执行
  2)do...while:先执行后判断，至少会执行一次
               第1要素与第3要素相同时首选
  3)for:固定次数循环










笔记:
1.三种循环结构的更佳适用情况:
  1)while:"当..."循环
  2)do...while:"直到..."循环
               第1要素与第3要素相同时首选
  3)for:固定次数循环，应用率最高
2.嵌套循环:
  1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
  2)执行规则:外层循环走一次，内层循环走所有次
  3)建议:层数越少越好，能用一层就不用两层，能用两层就不用三层
    若需要必须通过三层以上才能实现，说明设计有问题
  4)break只能跳出一层循环
3.程序=算法+数据结构
  1)算法:解决问题的流程/步骤(顺序、分支、循环结构)
  2)数据结构:将数据按照某种特定的结构来保存
             数怎么存
    设计良好的数据结构会导致好的算法
4.数组:
  1)相同数据类型元素的集合
  2)数组也是数据类型(引用类型)
  3)数组的定义:
      int[] arr = new int[4];
  4)数组的初始化:
      int[] arr = new int[3];       //0,0,0
 int[] arr = {1,4,7};          //1,4,7
 int[] arr = new int[]{1,4,7}; //1,4,7
 int[] arr;
 arr = {1,4,7}; //编译错误
      arr = new int[]{1,4,7}; //正确
  5)数组的访问:
    5.1)通过(数组名.length)获取数组的长度
     int[] arr = new int[3];
 System.out.println(arr.length); //3
5.2)通过下标来访问数组中的元素
   从0开始，最大到(数组的长度-1)
 int[] arr = new int[3];
 arr[0] = 100; //给第1个元素赋值为100
 arr[1] = 200;
 arr[2] = 300;
 arr[3] = 400; //数组下标越界异常
 System.out.println(arr[arr.length-1]);
  6)数组的遍历:
      int[] arr = new int[5];
 for(int i=0;i<arr.length;i++){
   arr[i] = 100;
 }
 for(int i=0;i<arr.length;i++){ //正序输出
   System.out.println(arr[i]);
 }
      for(int i=arr.length-1;i>=0;i--){ //倒序输出
   System.out.println(arr[i]);
 }
  7)数组的复制:
      System.arraycopy(a,1,a1,0,4);
 int[] a1 = Arrays.copyOf(a,6);
 a = Arrays.copyOf(a,a.length+1);
  8)数组的排序:
      Arrays.sort(arr); //升序
      冒泡原理:
        1)四个数冒三轮
        2)每一轮都是从第1个元素开始冒
          每一次都是和它的下一个元素比
        3)冒出来的就不带它玩了






任务:
1.将今天的4个经典案例，至少重写一次


今天晚上或明天，项目经理给大家发每周一做






BubbleSort




int[] arr = {23,5,89,1}; //升序


for(int i=0;i<arr.length-1;i++){ //控制轮
  for(int j=0;j<arr.length-1-i;j++){ //控制次
    if(arr[j]>arr[j+1]){ //每次和它的下一个元素比
 int t = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = t;
}
  }
}
    
arr.length-1-i
i=0 比3次
i=1 比2次
i=2 比1次


第一轮:
  23和5比，换，5,23,89,1
  23和89比，不换
  89和1比，换，5,23,1,89-----------89冒出来了
第二轮:
  5和23比，不换
  23和1比，换，5,1,23,89-----------23冒出来了
第三轮:
  5和1比，换，1,5,23,89------------5冒出来了






不同的数据，不同的排序方式效率是不同的


30万个数据--------------插入排序最快
30万个数据--------------冒泡排序最快
30万个数据--------------快速排序最快






long a = System.currentTimeMillis();
......
long b = System.currentTimeMillis();


System.out.println(b-a); //500




int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0


for(int i=0;i<a.length;i++){
  b[i] = a[i];
}


b[0] = a[0];
b[1] = a[1];
b[2] = a[2];
b[3] = a[3];
b[4] = a[4];






int[] arr = {2,23,56,4};
找最大值算法:
1.假设第一个数为最大值
    int max = arr[0];
2.遍历剩余元素，用剩余元素与max对比，
  若大于max，则修改max的值为较大的
    for(int i=1;i<arr.length;i++){
 if(arr[i]>max){
   max=arr[i];
 }
}


max=2/23/56




int a = 8; //4个字节


int[] arr = new int[10]; //40个字节




0-----------char的默认值为码0
'0'




ArrayDemo




int[] arr = new int[5];
for(int i=0;i<arr.length;i++){
  arr[i] = 100;
}






for(int i=0;i<arr.length;i++){
  System.out.println(arr[i]);
}




for(int i=arr.length-1;i>=0;i--){
  System.out.println(arr[i]);
}




System.out.println(arr[4]);
System.out.println(arr[3]);
System.out.println(arr[2]);
System.out.println(arr[1]);
System.out.println(arr[0]);




arr[0] = 100;
arr[1] = 100;
arr[2] = 100;
arr[3] = 100;
arr[4] = 100;




int[] arr = new int[3]; //0,0,0
arr[0] = 100; //给arr中第一个元素赋值为100
arr[1] = 200;
arr[2] = 300;
arr[3] = 400; //运行时异常----数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素






int a=0;
int b=0;
int c=0;
a=100;
b=200;
c=300;






arr[0]-------代表arr中的第1个元素
arr[1]-------             2
arr[2]-------             3








//声明布尔型数组b，包含26个元素
//每个元素都是boolean型，默认值为false
boolean[] b = new boolean[26];






//声明浮点型数组d，包含10个元素
//每个元素都是double型，默认值为0.0
double[] d = new double[10];




//声明整型数组a，包含5个元素
//每个元素都是int型，默认值为0
int[] a = new int[5]; //0,0,0,0,0




int   a; //声明整型变量a
int[] a; //声明整型数组变量a








将1万本书按照图书类别存储------设计数据结构
找java编程思想------------------算法简单




将1万本书按照出版社来存储------设计数据结构
找java编程思想------------------算法不简单






跳出多层循环------这个需求几乎没有


for(int i=1;i<=100;i++){
  for(int j=1;j<=200;j++){
    for(int k=1;k<=300;k++){
      System.out.println("aaa");
 if(){break};
}
  }
}






i=1
  j=1
    k走30次
  j=2
    k走30次
  ...
  j=20










1*9=9   2*9=18  3*9=27  








选择循环结构的规则:
1.先看是否是固定次数循环?
  1)固定次数时，选择for循环
  2)不固定次数时，再看要素1与要素3是否相同?
    2.1)相同时，首选do...while
2.1)不同时，首选while




int i = 0;
while(i<10){
  i++;
}
System.out.println(i); //10




int i;
for(i=0;i<10;i++){
}
System.out.println(i); //10










逻辑思维能力-------------几乎没有
听得懂，就是写不出来----------


——————————————————————————————————————————————————


int [] a= Arrays.copyOf(a,6);
System.arrayscopy(a,0,a1,1,10);
Arrsys.sort(arr); 


System.arrayscopy(a,0,a1,1,10);
Arrsys.sort(arr); 无返回值




int [] a= Arrays.copyOf(a,6); 有返回值






public static int sum(number1,number2) 
//修饰词；方法体；返回值类型；方法名（参数1，参数2）




有参更灵活
double c = Math.random(); //无参 0.0-0.999999999
double d = Math.sqrt(25); //有参




double c = Math.random(0，99); //0.0-9999999 




若方法不需要返回值就用 void
需要返回值 指定类型 int long string boolean或者char，或者引用类型Emp Person等等


方法和方法并列




只有字符数组java的System.out.println()才能直接输出，整型的不行。
System.out.println(arr)


boolean[] flags = new boolean[letters.length]; 默认false






int=0 index=0  false chs[0]='a' flags[0]=true
int=1 index=25 false chs[1]='a' flags[25]=true
int=2 index=0/25/0/25/0/25/1 false chs[2]='b' flags[1]
int=3




循环次数不固定，用while /do while


while(true)




11月二十几号讲：
String str = scan.next();
char[] input = str.toCharArray();


String.equals.(string2)
if ("EXIT".equals(inputStr)){}




基本类型相比较 用==
String 类型相比较用equals  if(str.equals("exit"))


——————————————————————————————————————————————————————
day06 




回顾:
1.适用情况:
  1)while:当...
  2)do...while:直到...
               要素1与要素3相同时首选 
  3)for:固定次数
2.嵌套循环:
    循环中套循环
外层一次，内层所有次
层数越少越好
break跳出一层循环
3.数组:
    相同数据类型元素的集合
是数据类型(引用类型)
int[] arr = new int[4];
    int[] arr = {1,4,6};
int[] arr = new int[]{1,4,6};
    arr[0] = 55;
System.out.println(arr[arr.length-1]);
    for(int i=0;i<arr.length;i++){
 arr[i] = 100;
}
    System.arraycopy(a,0,a1,1,4);
    int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
Arrays.sort(arr);
冒泡


正课:
1.方法:
  1)封装一段特定的业务逻辑功能
  2)尽可能的独立，一个方法只干一件事
  3)方法可以被反复调用多次
  4)避免代码重复，有利于代码的复用，有利于团队协作开发
2.
3.
4.return的用法:
  1)return 值; //1)结束方法的执行 2)返回结果给调用方法
  2)return;    //1)结束方法的执行


5.猜字符小游戏:






public static void main(String[] args){
  say();
  sayHi("zhangsan");
  int a = getNum(); 输出a的值
  double b = plus(5.5,6.6); 输出b的值
  double c=5.5,d=6.6; 
  double e = plus(c,d); 输出e的值
}
public static void say(){}
public static void sayHi(String name){}
public static int getNum(){
  return 88;
}
public static double plus(double num1,double num2){
  return num1+num2;
}






方法可以嵌套调用




if(){
  break;
}


if(){
  return;
}






MethodDemo




方法可以有参也可以无参，有参使方法更灵活








System.out.          println("HelloWorld");
System.              arraycopy(a,1,a1,0,4);
Arrays.              sort(arr);
double d = Math.     sqrt(25);
int[] a1 = Arrays.   copyOf(a,6);  //有参数


int a    = scan.     nextInt();
double b = scan.     nextDouble();
double c = Math.     random();     //无参数




double c = Math.random(); //0.0到0.99999999999...
double d = Math.sqrt(25);


假设random()有参:
double a = Math.random(1,1000);
double a = Math.random(0,99);
double a = Math.random(21,60);
double a = Math.random(0,26);












方法可以有返回值也可以没有返回值
  无返回值----返回值类型写成void
  有返回值----返回值类型写成具体的数据类型


若方法执行完以后，需要方法中的某个数据----有
若不需要方法中的某个数据------------------没有








System.out.println("HelloWorld");
System.arraycopy(a,1,a1,0,4);
Arrays.sort(arr);             无返回值


int a    = scan.nextInt();
double b = scan.nextDouble();
double c = Math.random();
double d = Math.sqrt(25);
int[] a1 = Arrays.copyOf(a,6);  有返回值






A:干一个业务
B:干一个业务
C:干一个业务






排序10个地方


排序(){
  冒泡6句话
}






System.out.println("HelloWorld");






a(){
  存
}
b(){
  取
}
c(){
  转
}


张三-------调a(),b(),c()
李四-------调a()
王五-------调b()
赵六-------调a(),c()






main(){
  调存----1
  调取----1
  调转----1
}
存(){
  500---调检测密码()
}
取(){
  500---调检测密码()
}
转(){
  1000---调检测密码()
}
检测密码(){
  
}






质数:又称素数，只能被1和它本身整除的数


何时是质数?------------取余所有都不得0
何时不是质数?----------只要有取余为0的




并非一次判断得结果----------------开关




5是质数:
  5%2/3/4-------------------都不得0
7是质数:
  7%2/3/4/5/6---------------都不得0
8不是质数:
  8%2/3/4/5/6/7-------------有取余为0的
9不是质数:
  9%2/3/4/5/6/7/8-----------有取余为0的






100
  %2/3/4/5/..../98/99
  %2/3/4/5/..../49/50
  %2/3/4/5/..../9/10


100%  51/52/53/54/.../98/99
100%  11/12/13/14/.../49/50






Math.sqrt(100)-----10.0


100平方根是10
25平方根是5
81平方根是9




-----------------------------------------------------------------
DAY07 OOP


OOP 本周讲4天，下周讲2天。然后做飞机大战案例3天


前4天，贯穿俄罗斯方块




面向过程也就是面向方法，面向函数


引用类型都需要借助new关键字
STRING
如int[] arr = new int[]
Emp e = new Emp();  //Emp为封装了的类。public class Emp{...}




---------------------------------------------------------------------------
1，找对象————一堆小格子对象
2，抽类——————cell类
3，设计类中成员变量和方法——————
4，创建对象并测试——————


class Cell{ //格子类
形状，颜色，宽 高 ————>图片
行号，列号




int row；//行号
int col //列号


void drop(){ //下落一格
 row++;
}
void moveleft(int n){ //左移
col-=n
}
//想获取行，获取的话需要返回值
int[] getCellInfo(){ //获取行号和列号
 int [] arr = new int[2] //数组太麻烦
}


String getCellInfo(){
return row+","+col
}

cell c = new cell()
类型 引用类型变量 指向 对象


new出来的对象都是放在堆中
基本类型 int = 5 因为没有new，放在栈中
Cell c = new Cell();  c 和保存的在堆中的数据的地址在栈中。如c 0x7797 
而Cell的row=0和col=0在堆中
————————————————————————
引用类型之间画等号：
1，指向同一个对象；如CellTest.java
2，对其中一个引用的修改影响另外一个
基本类型之间画等号：
eg：钥匙 ：引用。  房子：对象  配一把钥匙：另一个引用
1，赋值
2，对其中一个变量的修改不影响另一个
eg：身份证复印




---------------------------------------------------------------------------------------
overload 


同一个java文件中可以有多个类，但是只能有一个public
比如：public class a{
public void a(){}}
      class b{ public void b(){} }
跟返回值类型无关。如void say(){} 和int say(){return 1} 不能重载
与参数的名称无关。如void say(){String name} 和 int say(String age){}不能重载


下周整个面向对象结束，下下周讲API ——20161109


————————————————————————————————


凡是加()都是调方法




构造方法：5句话
1，常常用于给成员变量赋初值
2，与类同名 没有返回值。如class Cell{int row;int col; public Cell(int row1,int col1)}
3，在new对象时被自动调用；
4，没有构造方法系统自动给一个无参无内容的构造方法，有了就不给了
5，构造方法可以被重载




----------------------------------------------------------------------------
this；指代当前对象。哪个对象调用就指哪个。只能用在方法中。在访问成员变量之前都有个this
this.成员变量名 ————访问成员变量
this.方法名()————调用方法
this()——————————调用构造方法；




构造方法还是方法，方法可以被重载






---------------------------------------------------------------------------------
成员变量有默认值，一旦new了就有默认值
局部变量没有


--------------------------------------------------------------------------------
向上造型；


//父类型o1，能访问父类的成员；但是T特有的不能访问
Tetromino o1 = new T(1,2); //向上造型；父类型的引用o1指向子类对象T
printWall(o1); //先造型后传值；
//父类型j，能访问父类的成员；下面J的能访问的权限大于上面的Tetromino；
System.out.println("--<<<<<<<<<分割线->>>>>>>>>>>>--------");
J j = new J(6,6);
printWall(j); //传值的同时造型；


_______________________________________________________________________________
继承要符合IT‘S A 的关系，不要为了复用代码而随意继承。如：
class dog(){
String name;
int age;
class student extends dog(){}


______________________________________________________________________________
子类不能继承父类的构造方法，只能被调用。如：
class fu{
fu(){}
fu(int n){}
}
class zi{
zi(){}
}


Zi z = new Zi(6); //错误！子类不能继承父类的构造方法，只能被调用。子类无有参的构造函数
可以改成：
class fu{
fu(){}
fu(int n){}
}
class zi{
zi(){
super(n)
}
}




_________________________________________________________________________________


Override :
使用频率相当高
重写需遵循两同两小一大
两同：
1方法名相同
2参数列表相同
两小：
1，子类返回值类型小于或等于父类的。
1，void时，必须相等
2，基本类型时，必须相等
3，引用类型，小于或等于
如：
//父类大 ，子类小；
class Coo{
Coo say(){}
Doo sayHi(){}
}
class Doo{
Coo say(){}
Doo sayHi(){} //错误。
}
一大：






编译期：.java 到 .class 无对象，只能看引用类型
运行期： jvm运行。.class到.class； 内存中分配了空间给对象。


--------------------------------------------------------------------------------------------------------------


常见面试：override和overload的区别






4种修饰符；
public ：本类；同包类；
protected：
private
默认的：










成员变量：
1，实例变量：存在堆中，new几次就有几份
2，静态变量：存在方法区中，只有一份


实例方法：默认都有this，this接收当前对象。调用实例方法要先new对象
静态方法：无隐式的this，则无对象，无对象则实例变量无法用隐式的this传对象进静态方法。
所以，静态方法一定跟对象无关的，只跟参数有关。
静态方法不能访问非静态成员




静态方法：
Math.random();  //首字母大写可知Math是类名。要调用静态方法只能通过类名.静态方法名的方式
Math.sqrt();
Array.sort();


实例方法：
需要new，如
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();




静态块：
1，由static修饰
2，属于类的代码块，类被加载期间自动执行
因为类只加载一次，无论new多少次对象，所以静态块也只执行一次。
3，何时用：常常用于加载图片等，如游戏的图片，一开始就加载。




final
1，修饰变量 ： 变量不能被改变
2，修饰方法 ： 不能被重写
3，修饰类 ： 意味着不能被继承
final修饰成员变量，只有两种初始化方式
1，声明的同时初始化；
2，在构造方法中初始化；
final修饰局部变量，只要在用之前初始化即可
 class Hoo{
final int a=5;   //1，声明的同时初始化；
final int b;  
Hoo(){
b=6;          //2，构造方法中初始化
}
}




java中默认都可以重写，不想被重写则加final




------------------------------------------------------------------------------------------
static final:常量
1，必须声明的同时初始化
2，常常通过类名点来访问，不能被改变
3，建议：常量名所有的字母必须大写
4，




public class Poo{
public static final int COUNT=5;  //修饰词顺序无所谓
System.out.println(Poo.COUNT);
}
//编译器在编译时将常量直接替换为具体的值
//相当用于System.out.println(5)




-------------------------------------------------------------------------------------------
有方法体{}则不能用抽象
或者： class Shape  
{  //抽象类————不完整
double c;
abstract double area();抽象方法——不完整的。所以类也需要写抽象
}




抽象的类绝对不能new对象。


没写完的方法，就算抽象；如下
class Car{
...
...
void stop();  //不完整的方法，所以需要加上abstract。而又因为方法是abstract，所以类名前面也要加。
}
变成：
abstract class Car{
...
...
abstract void stop(); 
}
抽象类不能被实例化，只能被继承。
new shape //编译错误；
Shape s；//正确。声明了引用类型的引用；


Shape s = new shape();左边正确，因为是shape类型的引用，右边错误，不能new






抽象方法：
1，abstract修饰
2，方法不完整，只有方法的定义，没有方法体




抽象类：
1，由abstract修饰
2，包含抽象方法的类必须是抽象类
3，抽象类不能被实例化；
4，只能作为父类被继承。方法被子类重写；




absract class Shape{ //抽象类————不完整
double c;
abstract doble area (){} //抽象方法————不完整
}


class Square extends Shape{ //重写抽象方法，----变不完整为完整。
double area(){
return 0.0625*c*c;


n
抽象存在的意义
1,封装子类共有的属性和行为，实现代码的复用
2,为所有子类提供一种统一的类型---向上造型
3,可以包含抽象方法，为所有子类提供统一的入口。子类的具体实现不同，但定义是一致的




笔记:
1.访问控制修饰符:
  1)public:公开的，任何类
  2)private:私有的，本类
  3)protected:受保护的，本类、子类、同包类
  4)默认的:什么也不写，本类、同包类
  说明:
    1)类的访问修饰只能是public和默认的
2)类中成员访问修饰如上4种都可以
2.static:静态的
  1)静态变量:
    1.1)由static修饰
1.2)属于类的，存在方法区中，只有一份
1.3)常常通过类名.来访问
1.4)何时用:所有对象的数据都一样时使用
  2)静态方法:
    2.1)由static修饰
2.2)属于类的，存在方法区中，只有一份
2.3)常常通过类名.来访问
2.4)静态方法没有隐式this传递，
        所以静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
  3)静态块:
    3.1)由static修饰
3.2)属于类的代码块，类被加载期间自动执行
   因为类只被加载一次，所以静态块也只执行一次
3.3)何时用:常常用于加载/初始化静态资源(图片、音频、视频等)
3.final:最终的，单独应用的几率不大
  1)修饰变量:变量不能被改变
  2)修饰方法:方法不能被重写
  3)修饰类  :类不能被继承
4.static final:常量
  1)必须声明的同时初始化
  2)常常通过类名点来访问，不能被改变
  3)建议:常量名所有字母都大写
  4)在编译时被直接替换为具体的值，效率高
5.抽象方法:
  1)由abstract修饰
  2)只有方法的定义，没有具体的实现(连大括号都没有)
6.抽象类:
  1)由abstract修饰
  2)包含抽象方法的类必须是抽象类
    不包含抽象方法的类也可以声明为抽象类---我乐意
  3)抽象类不能被实例化
  4)抽象类是需要被继承的，子类:
    4.1)重写抽象类中的所有抽象方法----建议
4.2)也声明为抽象类----不建议
  5)抽象类的意义:
    5.1)封装子类所共有的属性和行为，实现代码复用
5.2)为所有子类提供一种统一的类型----向上造型
5.3)可以包含抽象方法，为所有子类提供了统一的入口,
   子类的具体实现不同，但定义是一致的
7.接口:
  1)是一个标准、规范----制定方
    遵守了这个标准就能干某件事------API之


---------------------------------------------------------------------------------------------
用static修饰的成员变量是属于对象的数据结构 错
用static修饰的成员变量是属于类
static成员变量存储在堆中 错
static成员变量存储在方法中


子类的访问权限得大于或等于父类的




抽象方法也是一种数据类型（引用类型），所以可以作为类型数组
---------------------------------------------------------------------------------------------


Day06
===============================================================================================


接口：
只包含常量或者抽象方法。




1.接口:
  1)是一个标准、规范
    遵守这个标准就能干某件事------API之后
  2)接口也是一种数据类型(引用类型)
  3)由interface定义，只能包含常量和抽象方法
  4)接口不能被实例化
  5)接口是需要被实现/继承的，实现类/子类:
      必须重写接口中的所有抽象方法
  6)一个类可以实现多个接口，
    若又继承又实现时，应先继承后实现
  7)接口可以继承接口
2.多态:
3.内部类:
4.面向对象总结:




interface Inter1{
public static final int NUM  5;
public abstract void show()；
int COUNT = 6; //默认public static final
void say(); //默认public abstract


int NUMBER; //编译错误，常量必须声明同时初始化
void test(){} //编译错误,   ——————————————————？是因为接口都是抽象的吗？




interface Inter1{
public void show();
public void say();
}
class Aoo implements Inter1{
//子类的访问权限得大于或等于父类的
void show();  //不加public则报错。因为接口默认类public，不写也算public，但是类不写则
//默认为默认修饰，默认修饰符的权限没有public大，只能同类同包。所以实现
//的类中重写的方法必须加上public
void say();
}


正解：
class Aoo implents Inter1{
public void show(){}
public void say(){}
}


接口可以继承接口，而且可以继承多个；
-----------------------------------------------------------------------------------------------------
可以多实现。
interface Inter2{
void test()
}
//必须先继承再实现
class Boo extends Aoo implements Inter1,Inter2




interface Inter1{ void show();}


interface Inter 2 implents Inter2{ void test(); }


class Boo implements Inter2{ 
void show(); //必须也要重写test，因为2继承类1；。
void test();  
}




例子：
Inter2 o2 = new Inter();  //编译错误，接口不能被实现
Inter2 o2 = new Aoo();  //向上造型；
Inter1 o3 = new Aoo();  //向上造型（前提是Inter2实现了Inter1），间接父子


---------------------------------------------------------------------------------------------------


接口和抽象类 的区别；
所有子类共有的，抽到父类中。用继承
部分子类共有的，抽到接口中。


符合既是 也是原则，使用接口


接口是继承的单根性的扩展。


“实现接口”与“继承父类”不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。并且，具体类需要实现这些接口中定义的所有抽象方法； 接口间可以存在继承关系，一个接口可以通过extends关键字继承另外多个接口。子接口继承了父接口中定义的所有方法。


-----------------------------------------------------------------------------------------------------
多态：
点出什么看引用类型，具体行为的实现要看对象


1.同一类型的引用，指向不同的对象时，有不同的实现


向上造型：
父类型的引用指向子类的对象
能造型成的类型：父类+所实现的接口
能点出什么看引用的类型




强制类型转换，成功的条件有2种：
引用所指向的对象，就是该类型；
引用所指向的对象，实现了该接口
不符合那两种条件则转换失败；
发生ClassCastException类型转换异常；
建议使用instanceof判断引用指向的对象是否是该类型


Aoo o1 = new Boo();
Boo o2 = (Boo)o1  //符合条件1
Inter1 o3 = (Inter1)o1; //符合条件2
Coo o4 = (Coo) o1 //ClassCastException类型转换异常；




interface




interface Inter7{}
class Foo{}
class Goo extends Foo implements Inter7{}
class Hoo extends Foo{}


main:
Foo o1=new Goo(); //向上造型
Goo o2=（Goo)o1 //o1所指向的对象Goo就是Goo类型
Inter7 o3=（Inter7）o1 //正确。o1指向的Goo确实实现了Inter7
？？？？？？？？？？？？？？/




















父类大，子类小；
自动：小到大
强制： 大到小


人 p1 = new 理发师（）  //向上造型，自动转
理发师 l = new 人（）； //错误







double num = Double.parseDouble(input.next());
double num = scan.nextDouble();




======================================================================================================


内部类，匿名内部类：


类中套类，外面的类成为外部类，里面的类


4.内部类中可以直接访问外部类的成员，包括私有的。


class Aoo{
private int a;
void test(){
Boo o - new Boo();
}
class show(){
System.out.println(a);
System.out.println(Aoo.this.a);
System.out.println(this.a); //编译错误
}}






匿名内部类：
1，想创建一个类的对象，并且对象只创建一次。
此时该类不必命名
2.
3.
4




常见面试题：
问：内部类有独立的.class么？
答：有


接口也会生成一个.class文件
//.java编译都会生成.class




面向对象三大特征：
封装 
1，类：封装的是对象的属性和行为
2，方法：封装的是具体的业务逻辑功能
3，访问控制修饰符：封装的是访问的权限
继承 
1，作用：代码的复用；
2，父类/基类：所有子类所共有的属性和行为
  子类/派生类：子类所特有的属性和行为；
3，子继承父之后哦，子具有：父+子
4，单一继承，多接口实现，传递性/符合is a关系
多态
1，意义：行为的多态，对象的多态
2，向上造型，强制类型转换，instanceof
3，多态的表现形式：
1，重写--根据对象的不同
2，重载--根据参数列表不同而多态，行为的多态。

---------------------------------------------------------------------------------------------------




shootgame
1，找对象 ：英雄机，敌人飞机，小蜜蜂，子弹
2，抽类： Hero，Airplane，Bee，Bullet
3，设计类中的成员变量和方法
4，创建类和测试














敌人飞机————能得分
BOSS飞机————能得分；




蜜蜂————奖励
大黄蜂————奖励


所以用接口
interface enemy{
int getScore();
}
interface Award{
int getType();
}




class FlyingObject{//飞行物
x,y,image,width,height
}








class Hero extends FlyingObject{//英雄机
life,doubleFile
}


class Airplane extends FlyingObject implements enemy{
int getScore(){return 5;}


}
class BossAirplane extends FlyingObject implements enemy{//BOSS飞机
int getScore(){return 20;}
}


class bee extends FlyingObject implements Award{

}
class bullet extends FlyingObject{


}




shotTest{




void set???(有参)-----------设置；
get（无参）————————
boolean


================================+++++++++++++++++++++++++++++++========================================
ShootGame Test Day2
1,画图，画对象； swing相关 c# java几乎无c端，以B/S为主  飞机大战用浏览器比C端好。
JFrame  JPanel 
2，敌人（敌机+小蜜蜂）入场
3，飞行物（敌机+小蜜蜂+英雄机+子弹）走一步
4，子弹入场






子弹入场；
1创建子弹对象
2将对象添加的到bullets数组中












敌人对象————————在窗口上产生的
子弹对象————-————英雄机产生的




TimerTask 按住ctrl点


timer.schedule(Aoo){
}


class Aoo extends TimerTask
变成：
timer.schedule(new TimerTask(){})  {
}


paint()方法调用的两种方法：
1.frame.setVisible(paint);
2,repaint();


================================+++++++++++++++++++++++++++====================================
MouseListener()
MouseMotionListener()


侦听器






MouseListener m1 = new MouseListener(){重写5个};
MouseMotionListener mm1 = new MouseMotionListener(){重写2个};


需要重写的太多，其他方法实际都没用上，因此，用Adapter


public abstract class MouseAdapter implements MouseListener, MouseWheelListener, MouseMotionListener


MouseAdapter已经实现了MouseListener, MouseWheelListener, MouseMotionListener接口
可以不需要重写全部方法，因为虽然是抽象类，但没有抽象方法；需要哪个方法就用哪个。
MouseAdapter 1 = new MouseAdapter(){};


this.addMouseListener(1)
this.addMouseMotionListener(l);




----------------------------------------------___+++++++++++++++++++++++++++++++++++++++++++++++__
ShootGame day3


1，先判断每个飞行对象达到越界的条件
2，在一个越界方法里统一处理越界的对象，以及对应数组长度的改变，旧与新数组；
3，碰撞。确定子弹达到碰撞的条件，X1 X2 Y1 Y2，以及英雄机如何得分，或得命和火力
4，碰到的即消失，放数组中最后一个，然后缩容
5，定位英雄机碰撞敌机的坐标
6，状态。给run做分支判断。










1，删除越界的飞行物  
//每个对象都有的，因此在父类。越界检查的方法体不同，因此抽象方法。需要返回越界的结果，因此boolean
飞机：X不变因为都是下落的。只需要判断y。当y超过整个窗口的高度，就算越界了
蜜蜂：因为X已经设定不越界，因此y和飞机一样。
子弹：子弹是直线上升，当y小于窗口的负的高。+，上负，下正；


for(飞行数组的长度遍历)
FlyingObject f = flying[i]
if(f.outOfBounds()){  //越界了，默认true，也就是越界了
从flyings数组中删除----删除30次。数组也要缩容。每删除一个缩一次效率不高。




SO，
int index=0 //也做新数组的下标
FlyingObject[] flyinglives = new  flyingObject[flyings.length]

for(int i=0;i<flyings.length;i++){
FlyingObject f = flyings[i]
if(f.){









2，子弹和敌人的碰撞 最复杂
飞行对象被子弹射中，只要子弹的x和y都在飞行对象的4个坐标内就算击中；


3，画分和命


4，英雄机和敌人的碰撞


5，画状态；


撞上之后：
1，敌人消失
2，英雄机减少命




class Bullet{
public boolean shoot(FlyingObject obj)




class FlyingObject{
//敌人被子弹撞
public boolean shoot(Bullet obj)










X1/Y1 X2
-----------------------
]
]
]
]
]
]
]
【】 ]
【】 ]
-------------------------
Y2




撞上之后：
1，玩家得分
英雄机得命或者火力
2，敌人消失；


玩家不操作只要碰到也会产生效果，因此是定时的，而定时的放到action方法里面


所有子弹对所有敌人的碰撞。所有对所有，用遍历；


for(int i i<bullet.length
Bullet b = bullets[i];
for(int j j<flying.length
//每个子弹跟每个敌人
FlyingObject f = [j]
if(f.shotBy(b)) //撞上了
判断撞的是敌人是得分or类型
得分，加分
类型
判断是给命还是火力






CLASS HERO{
//英雄机撞敌人
bollean hit(FlyingObject obj)
this英雄机
obj敌机




//英雄机撞敌人也是定时发生的，不操作也会碰撞；






final关键字修饰成员变量
声明时初始化或在构造方法中进行初始化,不能在其他方法中初始化。
如果初始化后再给其赋值，会编译错误




“实现接口”与“继承父类”不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。并且，具体类需要实现这些接口中定义的所有抽象方法； 接口间可以存在继承关系，一个接口可以通过extends关键字继承另外多个接口。子接口继承了父接口中定义的所


import, class和package的声明顺序：
package, import, class




子类可以重写(覆盖)父类的方法。方法的重写要遵循“两同两小一大”规则，“两同”即方法名相同，形参列表相同；“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；“一大”指的是子类方法的访问权限应比父类方法的访问范围更大或相等。 在Java语言中，允许多个方法的名称相同，但参数列表不同，称之为方法的重载。


JVM的内存结构有方法区，堆，栈等。其中方法区用于保存类的各种信息；
栈用于存放程序运行过程当中所有的局部变量；
堆一般用于存储使用new关键字创建的对象。 
类属于Java语言中引用类型的一种，不属于JVM的内存结构


static修饰的方法不需要针对某些对象进行操作，其运行结果仅仅与输入的参数有关。调用时直接用类名引用。由于static在调用时没有当前的对象this，因此在static方法中不能对非static成员(当前对象的属性和方法)进行访问，但是非static方法可以访问static成员。




-------------------------------------------------------------------------------------------


double b = Math.sqrt(25); //静态方法


假设sqrt不是静态的:


无论是m1,m2,m3,m4...m100，
  调用sqrt(25)方法，最终结果都一样
----------------sqrt()方法与对象无关，仅与参数相关




Math m1 = new Math();
double a = m1.sqrt(25); //5


Math m2 = new Math();
double b = m2.sqrt(25); //5


Math m3 = new Math();
double c = m3.sqrt(25); //5


Math m4 = new Math();
double d = m4.sqrt(25); //5






class Aoo{
  int a; //实例变量，只能由对象点来访问
  static int b; 
  
  void show(){ //有this
    System.out.println(this.a);
System.out.println(Aoo.b);
  }
  static void test(){ //没有this，意味着没有对象
    System.out.println(a); //编译错误
System.out.println(Aoo.b);
  }
}




——————————————————————————————————————————————————————————
Aoo o = new Aoo();


class Aoo{
  int a;
  void show(){
    int b;
System.out.println(a); //0
System.out.println(b); //编译错误。局部变量必须同时初始化，成员变量可以在第一次调用初始化
  }
}




class Aoo{
  int a;
  void show(int b){
    int c=5;
  }
}


---------------------------------------------————————————————————————————————————
drop()不适合做为静态的，
因为每个对象drop()之后的结果都是不一样的
意味着与对象有关----所以不适合做为静态的
静态方法只跟参数有关
class Cell{
  int row;
  int col;
  void drop(){
    row++;
  }
  void moveLeft(){
  }
  String getCellInfo(){
    
  }
}


————————————————————————————————————————————————————————


无论a1,a2,a3,...a100，
调sort()方法，只要arr一样，结果一定是一样的
说明sort()方法的操作仅与参数有关，而与对象无关


Arrays a1 = new Arrays();
a1.sort(arr);


Arrays a2 = new Arrays();
a2.sort(arr);


Arrays a3 = new Arrays();
a3.sort(arr);








假设sqrt()不是静态的:


无论m1,m2,m3,...m100，
.sqrt()时，只要参数是25，最终结果一定是5.0
说明，sqrt()方法仅与参数有关，而与对象无关


Math m1 = new Math();
double a = m1.sqrt(25);


Math m2 = new Math();
double b = m2.sqrt(25);


Math m3 = new Math();
double c = m3.sqrt(25);
——————————————————————————————————————————————————————————
静态方法没有隐式this的传递




静态方法没有隐式的this传递，
没有this意味着没有对象，
而实例成员必须对象来访问，


所以静态方法中不能直接访问实例成员




class Aoo{
  int a; //实例变量，对象点来访问
  static int b; //静态变量，类名点来访问


  void show(){ //有this
    System.out.println(this.a);
System.out.println(Aoo.b);
  }
  static void test(){ //没有this
    System.out.println(a); //编译错误。方法内没有a，由于没有this，也就没法使用this.a调用成员实例变量
System.out.println(Aoo.b);
  }
}




————————————————————————————————————————————————————————
2.多态:
  1)多态的意义:
    1.1)同一类型的引用，指向不同的对象时，有不同的实现
   ------行为的多态:cut(),run()...
1.2)同一个对象，被造型为不同的类型时，有不同的功能
   ------对象的多态:我、你、水...
  2)向上造型:
    2.1)父类型的引用指向子类的对象
2.2)能造型成的类型: 父类+所实现的接口
2.3)能点出来什么，看引用的类型
  3)强制类型转换，成功的条件有两种:
    3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现了该接口
  4)不符合那两种条件则转换失败，发生ClassCastException类型转换异常,
建议在强转之前使用instanceof判断引用指向的对象是否是该类型




————————————————————————————————————————————————————————
设计规则:
1)所有子类共有的属性和行为，抽到父类中
2)所有子类行为都一样，设计为普通方法
  所有子类行为不一样，设计为抽象方法
3)部分子类共有的行为，抽到接口中
  符合既是也是原则时，使用接口
  接口是对继承的单根性的扩展




——————————————————————————————————————————————————————————


类和类--------------继承
接口和接口----------继承
类和接口------------实现


Inter2 o1 = new Inter2(); //编译错误，接口不能被实例化
Inter2 o2 = new Aoo(); //向上造型--造型为直接父类
Inter1 o3 = new Aoo(); //向上造型--造型为间接父类




interface Inter1{
  void show();
}
interface Inter2 extends Inter1{
  void test();
}
class Aoo implements Inter2{
  public void test(){}
  public void show(){}
}


new Inter1(); //编译错误，接口不能被实例化
Inter1 o1; //正确




nterface Inter1{
  public static final int NUM = 5;
  public abstract void show();
  int COUNT = 6; //默认public static final
  void say(); //默认public abstract


  int NUMBER; //编译错误，常量必须声明同时初始化
  void test(){} //编译错误，抽象方法不能有方法体。接口的方法都是抽象的
}










class 驼鸟 extends 鸟{
  fly(){
    奔跑
  }
  main(){
    鸟 a = new 驼鸟();
a.fly();
  }
}
class 鸟{
  fly(){
    飞翔
  }
}