JAVA学习记录1（第一周）

前言：

        前10个学习视频讲解了java的基础知识，包括优势、运行环境、如何安装jdk并设置环境；10~20学习视频讲解了java入门程序、错误点总结、常用开发工具、eclipse的下载、使用和运行。截至算是初步认识了java,在大脑里形成了一个基本的框架。

一、java基础语法、快捷键的使用

        在靠前的一段学习中，我了解了一些写java程序的良好习惯，例如：注释、命名和定义时候的驼峰规则、代码的对应和对齐。随后，学习了一些java常用的关键字，这些都是组成java基本语法的重要部分。最初的时候对一些专有名词不太敏感，但随着往后学习，在一堆堆代码中逐渐了解其用法。例如：局部变量、静态变量、成员变量（后面学习知道静态的名词是static，成员变量常用于数组中）；final（有固定变量、方法、类的作用）。

        接着学习整型、浮点型变量。一个字节对应八位计算机中的二进制表达，byte(1字节，-2^7~2^-1)、short(2字节)、int(4字节)、long(8字节)，以0开头的数字代表八进制，以0x开头的数字代表十六进制，以0b开头的数代表二进制；float(4字节)、double(8字节)。   

         一些常用的快捷键:  ALT+/      、     先输入syso然后ALT+/

注意：

1.不做规定时定义的整型为int类型，定义的浮点型为double型。

2.定义浮点型为float时需要在数值后面加上f/F转换。

3.double和float都是不准确的，若要比较两个浮点值的大小，则要用到BigDecimal。

4.在给变量赋值的时候，要注意不同数据类型所能取值的范围，防止出现溢出问题。

二、字符型、算术、关系、位运算符和类型转换

        字符型类型由char定义，通常用来定义英文、中文字符和Unicode码，字符需要用  ' '  引用；与之对应的是字符串类型，用String定义，字符串则需要用  "  "  引用；转义字符\，其后面加上一些字符代表特殊使用方法，比如:  \t是制表符、\n表示换行......

*****算术运算符：+、-、*、/ 、%(加减乘除四则运算)   、+=、*=、-=、/=......

                                例如：a+=b;相当于a=a+b;    其他的以此类推

                                           %表示除以某个数取余

*****自增自减运算符：++、--

                a++相当于a=a+1，且a先带入运算再自增；而++a则是a先自增再带入运算，--自减类似

*****位运算符：

        1.&与          3+2=    0011

                               0010    = 0010=     2 （按位运算，同时为真才取1，一真一假、两假取0）

        2.|或           3+2=     0011

                                0010   =0011  =   3   （按位运算，有一个为真就取1）

        3.^异或      3+2=       0011

                                 0010=0001    =  1    （按位运算，只有两个不同时才取1）

        4.左移和右移运算

        int a = 12>>2;      //相当于12/2/2

        int b = 12<<2;      //相当于12*2*2

*****字符串连接符：+

        String a ="3";         int b = 4;         int c = 5;

        System.out.println(a+b+c);         345   //定义的a是字符串变量，将后面数字转化成字符串

        System.out.println(b+c+a);         93     //从左到右运算，4+5还是整型，到3时+才变成字符串                                                                         连接符

*****if语句用于判断,if是单选择结构，if-else是双选择结构，if-else  if-else是多选择结构；while用于符合条件则循环，不符合则跳出；for则是更为灵活的while

三、方法、对象和类

*****方法：     类名  xxx = new 类名 ();        //可以直接调用某个类的方法

*****方法重载：   方法名相同；参数的个数、类型、顺序不同都会构成重载

        例：public static int add(int n1,int n2);      public static int add(int n1,int n2 ,int n3); //个数不同

                                                                      public static double add(int n1,double n2);//类型不同

                                                                     public static double add(double n1,int n2);//顺序不同

*****构造方法：   

class point {
    double x,y;
    public point(double _x,double _y) {
        x=_x;
        y=_y;
        return;
    }
    public double getDistance(point p) {
        return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
        
    }
    
}

public class c21{
    public static void main(String[] args) {
        point p=new point(3.0,4.0);
        point o=new point(0.0,0.0);
        System.out.println(p.getDistance(o));
    }
}

四、继承、重写、封装、多态

*****继承  extends

class person/* 没有用extends 说明，直接默认时Object        */{
        String name;
        int height;
        public void rest() {
            System.out.println("休息");
        }
    }
    class student extends person{    //直接将上面person 的内容继承下来
        /*String name;
        int height;*/
        String major;
        public void study() {
            System.out.println("学习");
        }
        /*public void rest() {
            System.out.println("休息");
        }*/
    }

*****重写

class Vehicle{
        public void run(){
            System.out.println("跑");
        }
        public void stop() {
            System.out.println("停止");
        }
    }

        class Horse extends Vehicle{ //对父类的方法继承
            public void run() {     
                System.out.println("架架架");
            }   //相同的方法名，对父类进行重写

 *****封装

* 相当于电视机内部线路很复杂，而加了一个外壳却很简单，让别人看不到内部核心
 * 具有提高代码安全性，复用性特点
 * private:同一个类           default:同一个类，同一个包(什么都不加时候默认)
 * protected:同一个类、包，不同包的子类   public:同一个类、包，不同包的子类，所有类

public class c36 {
    public static void main(String[] args) {
        Human h= new Human();
    //    h.age=13; 不能对age赋值，因为private
        h.name="老八";
        h.height=180;
        System.out.println(h.name);
        System.out.println(h.height);
    }
}
class Human{
    private int age;
    String name;//默认default
    protected int height;
    void sayAge() {
        System.out.println(age);//必须在main方法下才能正常运行,并且main方法只能处于public class
    }
}
class Boy extends Human{
    void sayHello() {
    //    System.out.println(age);  子类同样不可使用父类
    }
}
 class Gril extends Human{
    void sayGood() {
        System.out.println(height);//没有报错就说明可以用，仔细看与最上面println的区别
    }
}

*****多态

public class c38 {
    public static void main(String[] args) {
        Animal a=new Animal();
        animalCry(a);   //调用a.shout方法
        Dog d=new Dog();//        向上转型：子类自动转为父类的类型dog--animal
        animalCry(d);
        animalCry(new Cat());//子类是什么就可以调用什么的方法，不需要大量重载
        
        Dog d2=(Dog)d;     //强制向下转型,将animal--dog
        d2.seedoor();
        //但是不能将cat--dog
    }
    static void animalCry(Animal a) {//Animal a是父类对象，调用子类对象Dog d时可以引用父类对象，发生了多态
        a.shout();                   //这部分是重载方法
    }
    /*如果没有多态将要写大量的重载方法
     * static void animalCry(Dog a){
     * a.shout();
     * }
     * 
     * static void animalCry(Cat a){
     * a.shout()
     * }
     * */
}
/*final*/class Animal{                       //类加上final,子类不能被继承，不能用extends
    public/* final*/ void shout() {         //如果加上final,下面就不能被重写
        System.out.println("叫了一声");
    }
}
class Dog extends Animal{     //
    public void shout() {
        System.out.println("汪汪汪");
    }
    public void seedoor() {
        System.out.println("看门");//如果dog(子类)有Animal(父类)没有的功能时，此时需要强制转型
    }
}
class Cat extends Animal{      //dog和cat都是方法重写
    public void shout(){
        System.out.println("喵喵喵");
    }
}

五、数组

public static void main(String[] args) {
        int[] arr01=new int[10];//定义数组的格式，10代表有十个整型元素
        String arr02[]=new String[5];
        
        arr01[0]=13;
        arr01[1]=15;
        arr01[2]=20;        //根据下标赋值
    
        for(int i=0;i<arr01.length;i++) {
            arr01[i]=10*i;
            System.out.println(arr01[i]);
        }
        //通过循环初始化数组
        /*for(int i=0;i<arr01.length;i++) {
            System.out.println(arr01[i]);
            }*/
        //通过循环打印数组中元素的值
        }