Java 2018.10.26~2018.10.31总结

总结

    1、java中的数据类型

     2、类和对象的关系分析

    3、构造方法和成员方法的区别

    4、方法重载和重写的区别

    5、面向对象三特征理解

            封装、继承、多态

1、java中的数据类型

        byte、short、int、long、float、double、char、boolean

 

数据类型	大小/bit	封装类	默认值	可表示数据范围
byte（字节）	8bit	Byte	0	-128-127
short（短整型）	16bit	Short	0	-32768-32767
int（整型）	32bit	Integer	0	-21亿-21亿
long（长整型）	64bit	Long	0L	-910亿亿-910亿亿
float（单精度）	32bit	Float	0.0F（必须加上F）
double（双精度）	64bit	Double	0.0D
char（字符）	16bit(Unicode)	Character	空	0-65535
boolean（逻辑）	8bit	Boolean	flase	1bit占一个位，分配一个字节，分配是字节分配

 

        数据类型对应的包装类

 

            public class PrimitiveTypeTest {  

    public static void main(String[] args) {  

        // byte  

        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  

        System.out.println("包装类：java.lang.Byte");  

        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  

        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  

        System.out.println();  

  

        // short  

        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  

        System.out.println("包装类：java.lang.Short");  

        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  

        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  

        System.out.println();  

  

        // int  

        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  

        System.out.println("包装类：java.lang.Integer");  

        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  

        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  

        System.out.println();  

  

        // long  

        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  

        System.out.println("包装类：java.lang.Long");  

        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  

        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  

        System.out.println();  

  

        // float  

        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  

        System.out.println("包装类：java.lang.Float");  

        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  

        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  

        System.out.println();  

  

        // double  

        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  

        System.out.println("包装类：java.lang.Double");  

        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  

        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  

        System.out.println();  

  

        // char  

        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  

        System.out.println("包装类：java.lang.Character");  

        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  

        System.out.println("最小值：Character.MIN_VALUE="  

                + (int) Character.MIN_VALUE);  

        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  

        System.out.println("最大值：Character.MAX_VALUE="  

                + (int) Character.MAX_VALUE);  

    }  

}

        强制类型转换：

             小范围可以自动转换成大范围

            将大数据转小数据，可以使用强制类型转换，可能会导致溢出或精度下降

            byte（1字节）不能转换成char（2字节）因为char没有负范围，所以需要强制转换

                    byte b='b';

                    char c=(char) g;

 

    2、java中的流程控制语句

         if(){

        }

         else 

 

       switch(表达式):

             {case 值:

                break;

             }

 

       default  可以在接口添加新功能特性，且不影响接口的实现类

            public class A implements B{

       public void saysomething(){

             System.out.println("hi");

       }

}

           public interface B {

       public void saysomething();

}

        接着想要在接口B中再写一个方法，但是不想让A来重写，这就要用到default

        public interface B {

       public void saysomething();

       

       default public void hi() {

             

       }

}

    且default要有方法体

    因为类可以实现多个接口，若这多个接口当中有相同的default方法，那么在实现接口类中就要重写接口的方法

    public class A implements B , C{

       public static void main(String[] args) {

             A a=new A();

             a.hi();

       }

       public void saysomething(){

             System.out.println("hi");

       }

        //想要调用哪个接口的default方法

       public void hi() {

             C.super.hi();

       }

}

    public interface B {

       public void saysomething();

       

       default public void hi() {

             System.out.println("B");

       }

}

    public interface C {

       default public void hi() {

             System.out.println("C");

       }

}

for(){}

  

do{

    }while() 

    

continue 退出本次循环进行下次循环      break退出当前循环 

return             goto    

   

  3、类和对象的关系分析

        什么是类？什么是对象？

            类是抽象的概念，描述对象的属性、行为，比如男孩

            对象是类的具体化，比如说具体的某个男孩就是一个对象

        类描述了一组具有相同属性和相同行为的对象

 

4、构造方法和成员方法的区别

        什么是构造方法？什么是成员方法？

        构造方法：类中没有声明构造方法则会默认一个无参的构造方法，作用是用来实例化对象

        成员方法：是对象行为的操作

        构造方法：1、要和类同名                        

                        2、不能被声明，不能有类型

                            private-->protected-->public

                        3、调用父类的构造方法使用super()

 

5、方法重写 和重载的区别

    重写：同名同参，子类重写父类的方法且访问限定符只能变大不可变小

    重载：同名不同参数个数或同名不同参数类型，必须在同一个类当中，与访问限定符无关

    都必须和原函数名相同

 

6、面向对象三特征：封装、多态、继承            

        什么是封装？什么是继承？什么是多态？

    

        封装是通过访问访问限定符，限制实例变量只能本类自己访问，外界想要访问本类的实例变量只能调用方法来访问，所以设置属性的访问限定符一般是private。

        public class Main {

       public static void main(String[] args) {

             Student stu=new Student();

             stu.setName("ljj");

             System.out.println("name:"+stu.getName());

       }

}

    public class Student {

       private String name;

       

       public void setName(String n) {

             this.name=n;

       }

       public String getName() {

             return this.name;

       }

}

    将用户不想看到的细节封装起来，在主函数中进行调用就行；具有安全性，有些属性是不想外界看到的，就需要封装起来

    继承是一个类（父类）派生出其他类，派生出的类称为子类，子类可以继承父类的非private方法和属性。

    

    为什么要继承呢？

        a:重用代码，减少冗余

        b:对父类进行扩展（主要目的），子类的属性和方法必须是子类类型的对象才可以使用

        c:可以重写父类的方法，使用的是父类的方法还是子类重写的方法取决与对象的类型

        继承示例：

        

        

        继承的类重写父类的方法：

            

            

            

            输出为：喵喵

                

            

            

            输出为：开心地喵喵

                

            所以重写父类方法时，使用的是父类的方法还是子类重写的方法取决与对象的类型  

  

        **注意**：java是单继承不是多继承；除Object外，任何类都仅有一个直接父类即Object；除Object外，任何类都至少有一个或多个父类，此处多个父类指

        

        

        

        那么C是A和B的父类

 

    类的继承中的构造方法：

        a.父类的构造方法子类不会继承只会调用

        b.子类构造方法中必须调用父类的构造方法
        c.默认情况下，子类的构造方法调用的是父类无参的构造方法super(),super()必须在子类构造方法的第一句

        d.如果父类没有无参的构造方法，子类就必须在构造方法中调用父类其他的已定义的构造方法

 

        多态：多种状态；同一个声明类的对象，调用相同的方法，得到的结果可能不同。比如调用一个画形状的方法，画出来的可能是矩形，可能是三角形或者其他。

                由于继承和重写机制导致的多态----动态多态

                动态多态：只有程序在运行是才能确定调用的是哪个方法或者使用的是哪个类

       

                 由于重载机制导致的多态----静态多态

                静态多态：编译时系统决定调用哪个函数

 

        

       结果： 

 

总结过程中才发现自己有些概念还有些模糊，及时查漏补缺，以后会多多总结