Java详解（5）--知识点总结2

Dos
打卡方式3种
dir
cd    cd ..    E:  F:   cd \
rd
md
echo class aa > aa.java
del

jdk
.java  ----java.exe----->.class---->java.exe----->结果

//   /*  */   /**    */

常量
变量  【修饰符】 类型    变量名  【 = 表达式 】{变量 = 表达式}
                成员变量                         堆
                局部变量       int x = 3;栈

数据类型
基本数据类型  byte 0  short  0  int 0  long     0L  float  0.0F  double      0.0D    
引用数据类型  数组    类    接口

强制转换  byte a = 2;
         a =  (byte)(a + 3);
         
运算符 
算术运算符  +  -  /  % ++   --
逻辑运算符  &  |   &&   ||
          &    运算最多
          &&   左边必须为真 右边才计算 
          
关系运算符
==   >=   <=     (equal)  

流控制语句
分支语言
if   if...else  swith(){
                                                    case 常量；break ；
                                                    default；
                                                    } 
break                                                 
continue

循环语言
for   while     do...while    初始部分   循环条件    循环体   迭代部分

数组 
一维数组
类型 [] 数组名 = new 类型[5];      
类型 数组名 [] = new 类型[]{12,232,343,545};  

二维数组        
类型 [][] 数组名 = new 类型[3][4];     

面向过程 -----》面向对象        操作者 ------》指挥者        

继承
        产生：很多类优相同属性，把起归类作为父类，直接继承 
        优点：代码的复用提高，让类与类之间的产生关系，这个关系导致出现了多态
        注意：只是为了获取父类的方法（功能）或者为了简化代码，就写父类【错】-----》is a  必须是有从属关系才能继承。    单继承------》多继承（接口）
        
        继承
        产生：很多类都有相同的属性，懒得多写直接继承（事物可以被描述，他们之间有一定的关系，而继承就是写关系中的一种）
        优点：提高类代码的复用性；让类与类之间产生类关系，有了这个关系，才有类多态。
        注意：不能为了获取其他类的功能、简化代码而继承，必须有所属关系才能继承。（不能随便认爹）

calss person
{
        string name;
        int age;
}    

calss student  extends person
{
        void study()
        {
                system.out.println("good study");
        }

}

calss Worker
{
        void work()
        {
                system.out.println("good work");
        }

}

calss Fusioninsigth()
{
            public static void main(String[] args)
            {
            system.out.println("hello word");
            }
}

抽象 abstract 修饰类  函数
当多个类中出现相同功能 但是功能主体不同 这是可以进行向上抽取。只抽取功能定义，而不抽取功能主体。
抽象类   
抽象方法一定在抽象类中;抽象类和抽象方法都必须被abstract修饰;抽象类不可以用new创建对象，调用抽象方法没意义;抽象类中的方法要被使用，必须由子类复写其所有抽象方法后，建立子类对象调用，若只覆盖了部分抽象方法，则该之类还是抽象类。
抽象类比一般类多了抽象函数，不可以实例化。抽象类可以不定义抽象方法，是为了不让该类建立对象。
抽象方法只需要给出方法声明，不需要给出方法体。不能将构造方法，类成员方法声明为抽象方法;abstract抽象方法不能和static同用;父类的非抽象方法可以被子类的抽象方法覆盖。  

public abstract class Pet{   } 抽象类 （为了限制实例化） 
public abstract void print();  抽象方法 
（抽象方法的三个特点：1、抽象方法没有方法体 2、抽象方法必须在抽象里 3、抽象方法必须在子类中被实现，除非子类是抽象类）

多态：
        多态
     定义：事物的多种体现形式
          实体类   对象上的体现  对象的多态性           动物  xx = new 动物（）；
  人：男人  女人        动物 ： 猫  狗   企鹅   猪          动物  xx = new 猫（）；
                            
       前提：类与类之间要有关系   实现/继承            
       体现：父类的应用指向了自己的子类                    
       好处：提高代码的扩展性，提高代码的维护和扩充              
       应用：（优缺点）缺点：只能使用父类的引用来调用父类的成员        
       
在程序中同一符号或名字在不同情况下具有不同的语义解释。
多态至始至终都是子类对象在做着变化

            
向上转型  Animal a=new Cat() 类型提升
声明一个父类类型的变量，但将子类的实例赋给了他。父类变量指向了子类对象
①使用子类强大的功能②抽取父类的共性
instanceof 判断一个对象是否属于指定类及其子类
子类隐藏父类的成员变量和静态方法，上转型对象引用的是父类的;
子类覆盖父类的实例方法，上转型对象引用的是子类的。(动态绑定:在运行时确定要调用父类还是子类)
private，static，final修饰的成员都属于静态绑定，在编译时确定要调用父类还是子类。
覆盖的方法不应有更窄的访问权限，不应产生更多的异常;静态方法和最终方法不能被覆盖。

向下转型 Cat c=(cat) a  想要调用子类特有方法，强制将父类的引用转成子类类型。
父类引用指向自己的子类对象时，该引用可以被提升，也可以被强制转换
Animal a=new Animal(); Cat c=(Cat) a;  (×)
成员函数的特点:编译时，参阅引用型变量(animal)所属的类中是否有调用的方法，若有编译通过，没有编译失败;运行时，参阅对象所属的类(cat)中是否有调用的方法。编译看左边，运行看右边。
成员变量的特点:编译和运行都参考左边(应用型变量所属的类)
静态成员函数的特点:同成员变量

接口   interface
提供了方法声明与方法实现相分离的机制
具备三个特征:公共性，静态的和最终的
声明接口的语法格式:
[public] interface 接口 [extends 父接口]  {
   [ public ] [static] [ final ] 数据类型  成员变量=常量值; 
   [public] [abstract] 返回值类型  成员方法 [(参数列表)];  
}
不可以创建对象;需要被子类实现implements，子类对接口中的抽象方法全部覆盖后，子类才可以实例化，否则子类是一个抽象类。
接口可以被类多实现，接口之间存在多继承。
接口的作用:多继承;解耦
对外暴露的规则;程序的功能拓展;降低耦合性
接口的特点:
①接口中的方法默认是public和abstract的(可省略)，但类在实现接口方法时一定要用public修饰，不能用protected，private，final和static修饰接口中的实例成员方法。
②接口中所有抽象方法必须全部被实现接口的类或其子类覆盖。
③接口中的成员变量都是常量
④接口不能被实例化
⑤接口是引用数据类型
⑥接口嵌入类中，可以使用private修饰
⑦嵌入接口中的接口，一定要为public
⑧public接口可以被任何一个类使用，不加public，为友好接口，可被同包中的类使用。
基本功能定义在类中，拓展功能定义在接口中。

接口和抽象类
相同点:
都包含抽象方法;都不能被实例化;都是引用数据类型
不同点:
①抽象类约定多个子类之间共同使用的方法;接口中约定多个互不相关类之间共同使用的方法
②抽象类与子类之间采用单重继承;一个类实现多个接口则实现了多重继承
③抽象类及其类中成员具有与普通类一样的访问权限;接口的访问权限只有public和默认，接口中成员的访问权限都是public
④抽象类中可以包含非抽象方法，也可以声明构造方法;接口中的方法全部是抽象方法，不能声明构造方法
⑤抽象类中可以声明成员变量，子类可以对该成员变量赋值;接口中只能声明常量
⑥接口是指这个东西"能做什么";类的意思是这个东西"是什么"。可以用"能做什么"来描述"是什么"，类的实例可以隐式转换为接口被使用。

6种变量类型:
类变量，实例变量，方法参数，构造函数参数，异常处理参数和局部变量
类变量包括在类中定义的静态数据成员以及在接口中声明的静态或非静态的数据成员。
        
内部类
         产生：访问每次访问其他类都需要new
         定义
    访问规则：
        1、内部类可以直接访问外部类的成员（内部类自带外部类的引用，格式 外部类.this ），包括私有的
        2、外部类要访问内部类，必须建立内部类对象

class  hehe{
        private int x = 3;    
     class  aa(){  ／／内部类
     
        int x = 4; 
             void fusioninsigth()
             {
             system.out.print("innner:"+this.x);
             }
     }
        void DataDemo()
        {
                aa in = new aa();
                in.fusioninsigth();
        }

}

class haha{
        public startic void main(String[] args)
        {
                haha out = new haha();
                out.DataDemo();
        }
        
}

IO流

File myDir = new File("C:/jdk1.5.0/src/java/io");（绝对路径）
String getName( ): 返回一个包含文件名但不包含路径的String对象，对于表示目录的File对象来说，只返回该目录的名称。
String getPath( ): 得到一个文件的路径名。
String getAbsolutePath( ):得到一个文件的绝对路径名。
String getParent( ): 得到一个文件的上一级目录名（父目录）。

boolean exists( )：测试当前File对象所指示的文件是否存在
boolean canWrite( )：测试当前文件对象是否可写
boolean canRead( )：测试当前文件是否可读
boolean isFile( )：测试当前文件对象是否是文件（不是目录）
boolean isDirectory( )：测试当前文件对象是否是目录

boolean delete( ): 删除当前文件。
boolean mkdir( ): 根据当前对象生成一个由该对象指定的路径。
String[ ] list( ): 列出当前目录下的文件，返回一个String数组。
File[ ] listFiles():列出当前目录下的文件，返回一个File数组。

字节流 ：所有数据都可以做成字节流
字符流 ：大部分文本都做成字符流（其他情况下基本不用）------》优点：速度快、效率高   汉字aa
字节流的父类是InputStream与OutputStream。字符流的父类是Reader与Writer。
public static final InputStream in ：
    标准输入，从标准输入获取输入（通常是键盘）
public static final PrintStream out ：
    标准输出，把输出送到缺省的显示（通常是显示器）
public static final PrintStream err ：
    标准输出，把错误信息送到缺省的显示

        
异常：

          int y = sc.nextInt();
          
      int z = x/y
      
  
        定义：其实就是java对不正常情况进行描述后的对象体现
        
        
Error 严重错误

Exception   抛出异常 

   
异常体系：
Throwable
            | - - Eroor
            
                 | - - Exception
        
                            | - - RumtimeException 
                            
特点：所有类和对象都可以抛出异常（具有可抛性）； 
         操作关键字：Throw 和 Throws ----->只有异常体系才能用到这两个关键字 

代码语法格式
1、try{ 

  int  z = x/y;
   int  y =  0; //(简称检测代码）

}    catch(){

}     

2、try{ 

                            （检测代码）

}finally {

                        （一定会执行的代码）
                        
}

3、try{ 

  int  z = x/y;
   int  y =  0; //(简称检测代码）

}    catch(){

                             (处理异常的代码)

}finally {

                                 （一定会执行的代码）

}
throw和throws的用法
            
            throw  定义在函数内，用于抛出异常       对象。
            throws 第一在函数上，用于抛出异常       类，可以抛出多个用逗号隔开。

集合
数组（同一数据类型的数据（元素）放到一起）------》数据类型太多（元素）太多-----》放到集合
List<String> strList = new ArrayList<>();
List<?> list = strList;  //只能进行一次赋值
object所有类的父类 

继承
        产生：很多类都有相同的属性，懒得多写直接继承（事物可以被描述，他们之间有一定的关系，而继承就是写关系中的一种）
        优点：提高类代码的复用性；让类与类之间产生类关系，有了这个关系，才有类多态。
        注意：不能为了获取其他类的功能、简化代码而继承，必须有所属关系才能继承。（不能随便认爹）
    
calss person
{
        string name;
        int age;
}    

calss student  extends person
{
        void study()
        {
                system.out.println("good study");
        }

}

calss Worker
{
        void work()
        {
                system.out.println("good work");
        }

}

calss Fusioninsigth()
{
            public static void main(String[] args)
            {
            system.out.println("hello word");
            }
}

内部类
         产生：访问一次需要new一次------>内部类 （用该类的方法和属性）
         定义：类的内部再创建一个类 （这个类相当于自己的一个方法或者属性） 
          访问规则：
          1、内部类可以直接访问外部类中的成员，还可以访问私有的成员； 访问格式：外部类名.this.成员
          2、外部类要访问内部类，必须要建立内部类的实例（对象）。
          // Oracle.Inter outInner = new Oracle().new Inter(); 
          
     
        
内部类
         产生：访问每次访问其他类都需要new
         定义
    访问规则：
        1、内部类可以直接访问外部类的成员（内部类自带外部类的引用，格式 外部类.this ），包括私有的
        2、外部类要访问内部类，必须建立内部类对象

class  hehe{
        private int x = 3;
        
     class  aa(){  ／／内部类
     
        int x = 4; 
             void fusioninsigth()
             {
             system.out.print("innner:"+x);
             }
     }

        
        void DataDemo()
        {
                aa in = new aa();
                in.fusioninsigth();
        }

}

class haha{
        public startic void main(String[] args)
        {
                haha out = new haha();
                out.DataDemo();
        }
        
}

成员内部类 
方法内部类
静态内部类
匿名内部类