JAVA学习笔记(1)

学习框架：

1.jdk（Java Development Kit）是java开发工具包，包含开发java程序所需的工具以及jre，用于开发java程序；
jre（Java Runtime Environment）是java运行环境，包含运行Java程序的核心类库以及jvm，用于运行java程序；
jvm（Java Virtual Machine）是java虚拟机，保证java程序跨平台，将java程序翻译成机器语言，交给底层操作系统，并保证运行效果，实现Java跨平台性；Java程序可以跨平台，jvm不能跨平台。jvm是用来保证Java程序跨平台，本身并不能跨平台。
2.利用JAVA_HOME存储jdk位置，然后在path变量中利用%JAVA_HOME%/bin来存储，方便以后的java
更新，只需改表JAVA_HOME的值即可（电脑右键属性高级设置…）
3.idea中，java程序以项目（project）的形式呈现
4.java程序最小的单元是类，一个java程序至少拥有一个类；
java程序的入口是main方法，编写方式固定：

public static void main(String[] args){}
System.out.println("the content to output")//控制台控制输出的语句

5.(1)
(2)
(3)
当你运行代码时，程序会先将源代码文件编译成字节码文件，存储到out目录下；
(4)
总结

6.java程序运行开发流程

7.快捷键

main方法：快捷键psvm加回车 输出语句快捷键：sout加回车
8.注释：解释程序；帮助调试程序错误；注释分为单行注释//，多行注释/* /,文档注释/* */；
关键字：被java语言赋予了特定含义的单词（组成关键字的字母全部小写；常见代码编辑器，对关键字有特殊颜色标记）
常量：程序执行过程中，其值不可以发生改变的量。（字面常量，自定义常量）
字面常量：
变量：程序执行过程中，其值可以在某个范围内发生变化的量，本质，内存中的一小块区域（计算机自动划分）

数据类型分类：

所占字节大小：

整形默认是int，定义long类型变量后面要加L
浮点型默认是double，定义float后面要加F（大小写均可，上面同）
9.类型转换

数据类型范围大小：byte,short,char->int(默认的整形)->long->float->double(默认的浮点型).(boolean型不参与比较,只有true 和 false两个值)
10.标识符：给类，方法，变量，常量等起名字的字符序列。

包：文件夹，用于区分重名类
11.运算符：对常量和变量进行运算操作的符号，程序对数据进行运算时要用到运算符；
加法运算特点：

		System.out.println("hello"+"world");//helloworld
        System.out.println("hello"+10+20);//hello1020
        System.out.println(10+20+"hello");//30hello
        //结合顺序不同得到答案不同

扩展赋值运算符的好处：省略了强制类型转换的操作

short s=1;
//s=s+1;报错(1是int,s+1类型是int不能赋值给short)
s+=1;//相当于 s=(short)(s+1);
System.out.println("s:"+s)://s:2

int a=10;
int b=20;
System.out.println(a=b)://是将b的值赋给a并输出

12.Scanner：扫描器，既可以通过Scanner类扫描用户在控制台录入的数据

//第一步:导包
import java.util.Scanner;
//使用Scanner类需要先导包(位置放到class定义的上边)
public class Scannerdemo {
    public static void main(String[] args) {
        //第二步：创建键盘录入对象
        Scanner sc=new Scanner(System.in);
        //使用一个类前，要先创建它的对象
        //第三步：接收数据
        System.out.println("请输入一个整数：");
        int i=sc.nextInt();//执行此代码时，控制台会等待用户录入数据
        //把获取的数据输出
        System.out.println("i:"+i);
    }
}

不需要创建两个Scanner对象来完成读取两个数，只需要一个对象即可；

//第一步:导包
import java.util.Scanner;
//使用Scanner类需要先导包
public class Scannerdemo {
    public static void main(String[] args) {
        Scanner sc1=new Scanner(System.in);
        int a=sc1.nextInt();
        int b=sc1.nextInt();
        System.out.println(a+b);
    }
}

13.顺序结构：代码会按照从上往下，从左往右的顺序，依次逐次执行；
选择结构：根据不同的条件选择不同的代码来执行的代码结构;
循环结构：一部分代码按照一定的次数或条件反复执行的一种代码结构

带标号的循环结束：

public class switchdemo {
    public static void main(String[] args) {
        classes:for (int i = 1; i < 4; i++) {
            for(int j=1;j<11;j++){
                System.out.println("finding the "+i+" class's "+j+" student");
                if(i==2&&j==5){
                    System.out.println("find the guy");
                    break classes;
                }
            }
            System.out.println();
        }
    }
}

14.random类：

import java.util.Random;
import java.util.Scanner;

public class switchdemo {
    public static void main(String[] args) {
        Random r=new Random();
        for(int i=0;i<10;i++) {
            int num = r.nextInt(10);//获取随机数的值在0-9,娶不到10
            System.out.println(num);
        }
    }
}

猜数字

import java.util.Random;
import java.util.Scanner;

public class switchdemo {
    public static void main(String[] args) {
        Random r=new Random();
        int guess=r.nextInt(100)+1;
        Scanner sc=new Scanner(System.in);
        while(true) {
            System.out.println("请录入你要猜的数字:");
            int guessnumber = sc.nextInt();
            if (guessnumber > guess) System.out.println("bigger");
            else if (guessnumber < guess) System.out.println("smaller");
            else {System.out.println("right");break;}
        }
    }
}

15.方法：


方法的格式：


方法和方法之间是平级的关系不能嵌套定义；

import java.util.Scanner;

public class switchdemo {
    public static int sum(int a,int b){
        int c=a+b;
        return c;
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        System.out.println(sum(a,b));

    }
}

方法调用

方法定义的注意事项：
1.方法必须定义在类中；
2.方法之间是平级关系不能嵌套（eg：不能再main方法里再写一个方法）
3.方法没有返回值时，也要有返回值类型void
4.方法返回值类型为void时，可以省略return语句
5.return语句后的数据类型必须和返回值类型匹配
6.return之后不能再放其他语句（return标志着方法的结束）

方法重载：

方法重载与方法的返回值类型，修饰符无关；只要方法名相同，参数列表不同就是方法重载；

import java.util.Random;
import java.util.Scanner;

public class switchdemo {
    public static boolean compare(int a,int b){
        return a==b;
    }
    public static boolean compare(long a,long b){
        return a==b;
    }
    public static boolean compare(double a,double b){
        return a==b;
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=10;
        int b=10;
        boolean flag1=compare(a,b);
        System.out.println("flag1 = " + flag1);
        System.out.println("----");
        long a1=10L;
        long b1=20L;
        boolean flag2=compare(a1,b1);
        System.out.println("flag2 = " + flag2);
        System.out.println("----");
        double a2=3.14;
        double b2=20.0;
        boolean flag3=compare(a2,b2);
        System.out.println("flag3 = " + flag3);
        System.out.println("----");

    }
}

16.数组

int[] a=new int [3]
int[] a=new int[]{1,2,3}
int[] a={1,2,3}

double数组默认的值是0.0；


动态初始化对应着数组的定义格式一，静态初始化对应着数组的定义格式二三；

变量名存储在栈里面，new出来的对象存储在堆里；Java看到new时就会向内存申请开辟空间；

数组索引越界异常

空指针异常

基本类型的变量作为参数传递时传的是值，引用类型的变量作为参数传递时，传的是地址值。
17.面向对象




类和对象：抽象概念和具体

简单定义一个手机类

注意成员变量定义在类中，方法外；成员方法去掉static修饰符

写时放在用一个package下：
类的定义；

package cn.cast.demo;

public class phone {
    //成员变量：定义在类中，方法外
    String brand;
    String model;
    String name;

    //成员方法：先不写static修饰符
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
    public void sendmessenger(){
        System.out.println("send text to somebody");
    }
    public void playphone(){
        System.out.println("play the games");
    }


}

主程序执行：

package cn.cast.demo;

//手机类的测试类;
public class testphone {
//main方法是程序的主入口，所有代码的执行都是从这里开始
public static void main(String[] args) {
phone p=new phone();//创建对象
    System.out.println(p.brand);//不赋值默认为null
    System.out.println(p.name);
    System.out.println(p.model);
//给成员变量赋值
    p.brand="iphone";
    p.model="6s";
    p.name="my phone";
    System.out.println(p.brand);//不赋值默认为null
    System.out.println(p.name);
    System.out.println(p.model);
    p.call("the Ghost");
    p.playphone();
    p.sendmessenger();
    /*null
null
null
iphone
my phone
6s
给the Ghost打电话
play the games
send text to somebody

Process finished with exit code 0
*/
}
}

写了public的类，是公用的，需要在类名.java文件下定义，main方法，可以和类写在同一个java文件下，但是不能用public关键字修饰；

package cn.cast.demo;
 class phone {
    //成员变量：定义在类中，方法外
    String brand;
    String model;
    String name;

    //成员方法：先不写static修饰符
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
    public void sendmessenger(){
        System.out.println("send text to somebody");
    }
    public void playphone(){
        System.out.println("play the games");
    }


}

//手机类的测试类;
public class testphone {
//main方法是程序的主入口，所有代码的执行都是从这里开始
public static void main(String[] args) {
phone p=new phone();//创建对象
    System.out.println(p.brand);//不赋值默认为null
    System.out.println(p.name);
    System.out.println(p.model);
//给成员变量赋值
    p.brand="iphone";
    p.model="6s";
    p.name="my phone";
    System.out.println(p.brand);//不赋值默认为null
    System.out.println(p.name);
    System.out.println(p.model);
    p.call("the Ghost");
    p.playphone();
    p.sendmessenger();
    /*null
null
null
iphone
my phone
6s
给the Ghost打电话
play the games
send text to somebody

Process finished with exit code 0
*/
}
}

一个对象的创建过程的内存图解

成员方法会存储到方法区中，并且会有地址值，在堆开辟的空间中，对象存储的成员方法的地址值，可以根据地址值，找到成员区的具体方法；创建的对象都是引用类型（把地址赋给他）；自定义类都是引用类型；当引用类型的变量作为参数传递时，它传递的是地址值。
Java中使用变量遵循就近原则，如果参数列表有就使用，没有就去本类的成员变量去找，如果还没有就报错（不严谨，有了继承，还可以去他的父类找）；


成员位置：类中，方法外；局部位置：方法的参数列表或者方法体语句（方法内部）

成员变量和局部变量的区别：


封装：

private关键字：

eg：
private一般用来修饰成员变量；public一般用来修饰成员方法

package cn.cast.demo;
public class Student {
    String name;
    private int age;
    //提供公共的访问方式，分别是设置值，获取值
    public void setAge(int a){
        //可以在此对age的值进行限定
        //可以写但没必要
        //因为从前端传来的数据本身就是已经校验过的合法数据
       /* if(a>200||a<=0){
            //非法值
            age=1;
        }
        else{
            age=a;
        }*/
        age=a;
    }
    public int getAge(){
        return age;
    }

    public void study(){
        System.out.println( name+" are studying");
    }

}


package cn.cast.demo;

import java.util.Scanner;

public class testStudent {
    public static void main(String[] args) {
        Student s=new Student();
        /*此时此语句就无法直接访问修改age了s.age=22;
        s.name="roxanne";
        System.out.println(s.age);*/
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        s.setAge(n);
        System.out.println(s.getAge());
        s.name="张三";
        s.study();
    }
}

this关键字

package cn.cast.demo;
public class Student {
    String name;
    private int age=20;
    //提供公共的访问方式，分别是设置值，获取值
    public void setAge(int age){
       
        this.age=age;
    }
    public int getAge(){
        return age;
    }

    public void study(){
        System.out.println( name+" are studying");
    }

}

package cn.cast.demo;

import java.util.Scanner;

public class testStudent {
    public static void main(String[] args) {
        Student s=new Student();
        /*此时此语句就无法直接访问修改age了s.age=22;
        s.name="roxanne";
        System.out.println(s.age);*/
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        s.setAge(n);
        System.out.println(s.getAge());
        s.name="张三";
        s.study();
    }
}

构造方法没有返回值，但是里面可以写return;在写构造方法时写了带参构造，要补一个无参构造，因为你写了构造函数，系统不会再提供无参构造；

必须具备公共的无参构造方法，也会加一个全参构造，所有成员变量必须要用private修饰，并提供对应的get set方法；





继承：

package cn.cast.demo;

//定义一个父类
public class Parent {
    private String name;
    private int age;
    //快捷键：alt+insert,or右键generate快速生成构造方法和getXX(),setXXX()
    public Parent() {
    }

    public Parent(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}


package cn.cast.demo;

public class Child extends Parent{
}


package cn.cast.demo;

public class testChild {
    public static void main(String[] args) {
        Child c=new Child();
        c.setName("zhangsan");
        System.out.println(c.getName());
        //c.name="lisi";无法访问父类的private对象
    }
}

package cn.cast.demo;

public class Dog {
    private String name;
    private int age;
    private String sex;

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void eating(){
        System.out.println("eating!");
    }
    public void watch(){
        System.out.println("watching!");
    }
}


package cn.cast.demo;

public class Pig {
    private String name;
    private int age;
    private String sex;

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void eating(){
        System.out.println("eating!");
    }
    public void snoring(){
        System.out.println("snoring!");
    }
}



package cn.cast.demo;

public class testAnimal {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.eating();
        d.watch();
        System.out.println("--------");
        Pig p=new Pig();
        p.eating();
        p.snoring();

    }
}

利用继承来写：

package cn.cast.demo2;

public class Test {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.eating();
        d.watch();
        System.out.println("--------");
        Pig p=new Pig();
        p.eating();
        p.snore();

    }
}


package cn.cast.demo2;
//父类，里面放的是共性内容
public class Animal {
    private String name;
    private int age;
    private String sex;

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void eating(){
        System.out.println("eating!");
    }
}



package cn.cast.demo2;

public class Dog extends Animal{
    public void watch(){
        System.out.println("watch");
    }

}


package cn.cast.demo2;

public class Pig extends Animal{
public void snore(){
    System.out.println("snore");
}

}

继承的优缺点：




java中使用变量的规则，遵循就近原则：局部位置有就使用，没有就去本类的成员位置找，有就使用，没有就去父类的成员位置找，有就使用，没有就报错；


java中类的成员没有写修饰符默认为default不需要书写，也称package，是指同一个包内可以访问到这个类

成员变量使用结论：

this和super：

如果局部变量，本类的成员变量，父类的成员变量重名了，如何解决？
直接写变量名：局部变量；
this.成员变量：本类的成员变量；
super.成员变量：父类的成员变量；





子父类构造方法：

package cn.cast.demo5;

public class Person {
    public Person(String name){
        System.out.println("Person类的带参构造"+name);
        //System.out.println("Person类的无参构造");
    }

}


package cn.cast.demo5;

public class Worker extends Person{
    public Worker(){
        super("xiaohei");
        //super();用于初始化父类成员的，必须放在第一行
        System.out.println("Worker类的无参构造");
    }

}

package cn.cast.demo5;

public class Test {
    public static void main(String[] args) {
    Worker w=new Worker();
//子类构造方法的第一行都有一个默认的super()用来访问父类的无参构造方法
// 如果父类没有无参构造，可以通过super（参数）的形式访问父类的带参构造；


    }
}

四大权限符的修饰范围从小到大分别是：private，默认（什么都不写就是默认），protected，public

子类指其他包下的子类；

在本类中不管使用那个权限修饰符，都可以访问；

同包下的类，只有用private修饰的不能调用；
不同包下的子类，可以访问protected public
不同包下的无关类，只能访问public

总结：
private：强调给自己使用；
默认：强调给同包下的类使用；
protected：强调的是给子类使用（不管是不是在一个包下）；
public：强调给大家使用；

方法重载指同一个类中出现两个或两个以上的同名方法时，这些方法的参数列表不同，与返回值的类型，以及修饰符无关
方法重写指的是子类出现和父类一样的方法时，要求返回值的类型必须相同

java继承的特点




多态：

多态：多种状态，同一对象在不同情况下表现出的不同的状态或行为；

package cn.cast.demo6;

public class Dog extends Animal{
    //因为狗吃骨头，所以要优化父类的方法
    @Override
    public void eat(){
    //getname前加super也可以
        System.out.println(getName()+"eat bones");
    }

}


package cn.cast.demo6;

public class Animal {
    private  String name;

    public Animal() {
    }//空参构造

    public Animal(String name) {
        this.name = name;
    }//全参构造

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("eating");
    }

}


package cn.cast.demo6;

public class Test {
    public static void main(String[] args) {
        //演示多态；
        //实现多态的三个步骤
        //1.要有继承或者实现的关系
        //2.要有方法重写
        //3.要有父类引用指向子类对象
        Animal an= new Dog();
        an.eat();

    }
}

//测试成员方法的调用
//多态中调用成员方法是编译看左(左边的类型有没有这个成员，有的话编译不会报错
// 运行看右(运行时具体用的是右边类中的该成员

静态方法可以在不创建该类对象的情况下直接用方法名调用该方法

package cn.cast.demo7;

public class Animal {
    private  String name;

    public Animal() {
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("eating");
    }

}

package cn.cast.demo7;

public class Mouse extends Animal{
    @Override
    public void eat(){
        System.out.println(getName()+" eating cheese");
    }
}

package cn.cast.demo7;

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println(getName()+" eating bones");
    }
}

package cn.cast.demo7;

/*
已知父类Animal,成员变量为姓名，成员方法为eat(),
他有两个子类 Dog类和Mouse类,两个子类都重写了Animal中的eat方法
在测试类中，定义了showAnimal方法用来测试Dog类和Mouse类
 */
public class Test {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.setName("hashiqi");
        showAnimal(d);
        //测试狗类

        //测试老鼠类
        Mouse m=new Mouse();
        m.setName("miqi");
        showAnimal(m);

    }
    //这样做很麻烦
    /*public static void showAnimal(Dog d){
        d.eat();
    }
    public static void showAnimal(Mouse m){
        m.eat();
    }*/

    //多态做法
    //多态的使用场景，父类可以作为形参的数据类型，这样可以接受任意的其子类对象
    public static void showAnimal(Animal a){
        a.eat();}
}

自定义类型属于引用类型，他在作为参数传递时传递的其实是地址值


多态关系中成员变量不涉及到重写的；多态关系中，使用成员变量遵循 编译看左，运行看左
编译看左：在编译期间，会看左边的类型有没有这个成员，没有就报错，有就不报错
运行看左：在运行期间使用的是，左边的的类型的这个成员


多态的好处和弊端

父类子类共有的方法才可以用多态（编译看左运行看右），但如果你一定要用，可以利用类型转换

package cn.cast.demo8;

public class Animal {
    public  void eat(){
        System.out.println("chifan");
    }
}

package cn.cast.demo8;

public class Dog extends Animal{
    @Override
    public void eat()
    {
        System.out.println("gouchigutou");
    }
    //狗类独有的方法，父类中没有
    public void watch(){
        System.out.println("kanjia");
    }

}

package cn.cast.demo8;

public class Cat extends Animal{
}

package cn.cast.demo8;

public class Test {
    public static void main(String[] args) {
        //通过多态创建对象，调用子类中的成员
        Animal a=new Animal();
        a.eat();//chifan
        Animal an =new Dog();
        an.eat();//gouchigutou
        //调用watch方法，子类独有方法
        //an.watch();报错，父类引用不能使用子类的特有成员，想要使用只能通过向下转型实现；
        /*正确的写法
        Dog dog=(Dog) an;
        dog.watch();//kanjia*/
        //不正常的转换
        //Cat c=(Cat)an;ClassCastException
        //狗转动物，动物转猫不可能！
        //只能在继承层次内转换

        //优化后的方案
        //先判断当前对象是否是dog类的对象，如果是再调用watch()方法
        if(an instanceof Dog){
            //判断an是否是dog类型的对象
            //能走到这里说明条件满足
            Dog dog=(Dog) an;
            dog.watch();
        }
    }
}

抽象类：

package cn.cast.demo9;

//抽象类
public abstract class Animal {
    //抽象方法(特点，要求子类必须重写）
    public abstract void eat();

}

package cn.cast.demo9;

public class Dog extends Animal{
    @Override

    public void eat() {
        System.out.println("gouchigutou");
    }
}

package cn.cast.demo9;

public class Mouse extends Animal{
    @Override
    public void eat() {
        System.out.println("laoshichinailao");
    }
}

package cn.cast.demo9;

public class Test {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.eat();
        Mouse m=new Mouse();
        m.eat();
        /*gouchigutou
        laoshichinailao通过普通方法测试*/
        //通过多态测试
        Animal a= new Dog();
        a.eat();//gouchigutou
    }
}

抽象类是不能new的

成员：成员变量，成员方法，构造方法

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类中的成员比普通类多一种：抽象方法，其它和普通类一样；

package cn.cast.demo10;

public abstract class Animal {
    //抽象类
    public abstract void eat();
    public abstract void sleep();//两个都去掉也不会报错
    String name="哈士奇";//成员变量，其值可以发生变化
    final int AGE=10;//成员常量，其值不能发生改变
    public void call(){
        System.out.println("huhhhh");
    }
    //构造方法
    public Animal(){}
    public Animal(String name){
        this.name=name;
    }

}


package cn.cast.demo10;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("maochiyu");
    }

    @Override
    public void sleep() {
        System.out.println("maotangzheshui");
    }
}


package cn.cast.demo10;

public abstract class Dog extends Animal{
    //如果是抽象类，则不用重写抽象方法
}


package cn.cast.demo10;

public class Test {
    public static void main(String[] args) {
        //Animal a=new Animal() ;这样写是错误的，抽象类不能被实例化
        //初始化抽象类
        Animal a=new Cat();
        System.out.println("---------");
        //抽象类的成员特点
        a.name="tom";
        System.out.println(a.name);
        //a.AGE=50;会报错，因为常量的值不能发生改变
        //但是可以输出
        System.out.println(a.AGE);
    }
}

实际案例：

package cn.cast.demo10;

public abstract class Employee {
    private String name;
    private double salary;
    private String id;
    public abstract void work();

    public Employee() {
    }

    public Employee(String name, double salary, String id) {
        this.name = name;
        this.salary = salary;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

package cn.cast.demo10;

public class Manager extends Employee{
    public Manager() {
    }

    public Manager(String name, double salary, String id, int bonus) {
        super(name, salary, id);
        this.bonus = bonus;
    }

    @Override
    public void work() {

        System.out.println("真香");
    }
    private int bonus;

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }
}

package cn.cast.demo10;

public class coder extends Employee{
    //小细节:在实际开发中，子类一般都有两个构造方法；
    //子类的空参构造访问父类的空参构造
    //子类的全参构造访问父类的全参构造
    private int mimi;
    public coder() {
        //super();默认访问
    }

    public coder(String name, double salary, String id) {
        super(name, salary, id);
    }

    //有独有的成员变量也可以赋值；
    public coder(String name, double salary, String id, int mimi) {
        super(name, salary, id);
        this.mimi = mimi;
    }

    @Override
    public void work() {
        System.out.println("程序员要敲代码");
    }
}

package cn.cast.demo10;

public class Test {
    public static void main(String[] args) {
        Employee m=new coder();
        m.work();

        Employee x=new Manager();
        x.work();
        System.out.println("---------");
        //快速实例化对象
        //需求：创建一个姓名为张山，工资5000，工号 研发部007的程序员
       /* coder c=new coder();
        *//*c.setId("yanfabu007");
        c.setName("zhangshan");
        c.setSalary(5000);
        System.out.println("name:"+c.getName());
        System.out.println("salary:"+c.getSalary());
        System.out.println("id:"+c.getId());*/
        coder c= new coder("zhangan",5000,"yanfabu007");
        System.out.println("name:"+c.getName());
        System.out.println("salary:"+c.getSalary());
        System.out.println("id:"+c.getId());
        Manager ma= new Manager("lisi",40000,"yanfabu001",5000);
        System.out.println("name:"+ma.getName());
        System.out.println("salary:"+ma.getSalary());
        System.out.println("id:"+ma.getId());
        System.out.println("bonus:"+ma.getBonus());
        //程序员要敲代码
        //真香
        //---------
        //name:zhangan
        //salary:5000.0
        //id:yanfabu007
        //name:lisi
        //salary:40000.0
        //id:yanfabu001
        //bonus:5000

    }
}

final关键字，用于修饰类，方法和变量
修饰类：该类不能被继承 eg：String System，但是可以继承其他的类（有他的父类）
修饰方法：该方法不能被重写，不能与abstract(用它修饰的方法必须被重写)共存；
修饰变量：最终变量即常量，只能赋值一次。（如果修饰引用类型的数据变量，地址值不能变化，但是该地址值之间的属性值可以发生变化。）（不建议修饰引用类型的数据，因为仍然可以通过引用修改对象的内部数据，意义不大）

package cn.cast.demo11;

public  class Employee /*extends Person*/{
    String name;
    int age;
    public final void show(){
        System.out.println("classified");
    }

}

package cn.cast.demo11;

public class Coder extends Employee{
    /*@Override
    public void show() {
        System.out.println("trash");
    }被final修饰的方法不能被重写*/
}

package cn.cast.demo11;

public class Test {
    public static void main(String[] args) {
        Employee e=new Coder();
        e.show();
        System.out.println("************");
        //final修饰的变量：基本类型的变量，其值不能改变
        final int NUM=10;
        //NUM=30;不能被修改
        System.out.println("NUM = " + NUM);
        //final修饰的变量：引用类型的变量，地址值不能改变，但是属性值可以发生变化
        final Employee ee=new Employee();
        //ee=new Employee();代码报错，只要new就会开辟新空间，地址值会发生变化，final不允许
        System.out.println("name:"+ee.name);
        System.out.println("age:"+ee.age);
        //name:null
        //age:0
        ee.name="roxxane";
        ee.age=23;
        System.out.println("name:"+ee.name);
        System.out.println("age:"+ee.age);
        //name:roxxane
        //age:23



    }
}

static关键字

package cn.cast.demo9;

public class Developer {
    String name;
    String work;
    //公共的静态常量，名字要全大写
    public final static String departmentname="yanfabu";
    //前加final防止别人修改
    public void selfIntroduction(){
        System.out.println("woshi "+departmentname+
                " de "+name+" wodegongzuoshi "+work);

    }

}

package cn.cast.demo9;

public class Test {
    public static void main(String[] args) {
        Developer d1=new Developer();
        d1.name="xiaohei";
        d1.work="xiedaima";
        //d1.departmentname="yanfabu";
        d1.departmentname="daoluan";
        //被static修饰的内容，被该类的所有的对象共享，这里改了之后，下面的d2也是daoluan
        d1.selfIntroduction();

        Developer d2=new Developer();
        d2.name="xiaoji";
        d2.work="chuiniubi";
        //d2.departmentname="yanfabu";
        d2.selfIntroduction();
       //woshi yanfabu de xiaohei wodegongzuoshi xiedaima
        // woshi yanfabu de xiaoji wodegongzuoshi chuiniubi
        System.out.println("----------------");
        //随着公司的发展，部门名字要进行调整，改为：开发部
        Developer.departmentname="kaifabu";
        d1.selfIntroduction();
        d2.selfIntroduction();
        //woshi daoluan de xiaohei wodegongzuoshi xiedaima
        //woshi daoluan de xiaoji wodegongzuoshi chuiniubi
        //----------------
        //woshi kaifabu de xiaohei wodegongzuoshi xiedaima
        //woshi kaifabu de xiaoji wodegongzuoshi chuiniubi


    }
}

当你调用一个方法时，想通过类名.方式调用，不是通过对象.方式调用，就可以考虑使用静态方法了

package cn.cast.demo8;

public class Reverse {
    int num1=10;
    static int num2=20;
    public static void show(){
        //System.out.println(num1);
        //报错，静态方法里面没有关键字this所以不能访问非静态成员（非静态成员）
        //属于对象的，只有当你有对象的时候他才存在，静态成员是属于类的，类是要优先对象存在
        System.out.println("num2 = " + num2);
   }
    public static void reverseArray(int[] arr){
        int length=arr.length;
        //交换次数等于数组长度/2；
        for(int i=0;i<length/2;i++){
            int temp=arr[i];
            arr[i]=arr[length-i-1];
            arr[length-i-1]=temp;
        }
    }
}

package cn.cast.demo8;

public class Test {
    public static void main(String[] args) {
        Reverse.show();
        int[] a={1,6,4,5,2,3};
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }
        Reverse.reverseArray(a);
        for (int i = 0; i <a.length ; i++) {
            System.out.print(a[i]);
            if(i!=a.length-1) System.out.print(" ");
            else System.out.println();
        }
    }
}