java基础阶段1

java基础语法：

1、基础数据类型：

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

整型:byte(1个字节),short(2个字节),int(4个字节),long(8个字节)，long的默认值为0.0l，其余三个默认值都为0;

浮点型:float(4个字节，单精度浮点型),double(8个字节，双精度浮点型);

字符型:char(2个字节，默认值为\u0000(空格));

布尔型:boolean(true\false);

注意:两个或多个byte类型变量做运算，需要给定类型，eg:

 byte b1=21;
        byte b2=22;
        byte b3=(byte) (b1+b2);

因为(b1+b2)是int类型，如果用byte类型的b3来接收会造成损失，编译器会报错，所以使用(byte)转换类型.

2、Scanner:获取从键盘上输入的数据:

import java.util.Scanner;//需要导入java提供的类

public class test {
    public static void main(String[] args) {
        System.out.println("请输入你猜的数字:");
        Scanner sc=new Scanner(System.in);
        int se=sc.nextInt();//获取整形类型
        String text=sc.next();//获取字符串类型数据
        double ss=sc.nextDouble();//获取double类型数据，还有很多api，可以自己试一试
       
}

3、Random随机数:

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

public class Randomdemo01 {
    public static void main(String[] args) {
        Random s=new Random();
        Scanner r=new Scanner(System.in);
        int data=s.nextInt(100)+1;//将随机数的范围设置在1-100之间，其为[)形式
}

4、for循环:

public class fortest {
    public static void main(String[] args) {
        //循环四次，i++为自增，i++等价于i=i+1或者i+=1；
        for (int i = 0; i < 4; i++) {    
                System.out.println("*");
        }
    }
}

//for循环嵌套
public class TWOfor {
    public static void main(String[] args) {
        //执行4*5=20次
        for (int i = 0; i < 4; i++) {
            for (int i1 = 0; i1 < 5; i1++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

5、while循环：

public class While_demo01 {
    public static void main(String[] args) {
        double height=8848860;
        double small=0.1;
        int i=0;
        while (small<height){//当small<height时，进入循环，当small>=height时，跳出循环
            small*=2;//等价于small=samll*2;
            i++;
        }
        System.out.println(i);
    }
}

6、swicth选择语句:

public class Swicth_demo01 {
    public static void main(String[] args) {
        //目标: 学会使用switch分支结构，理解流程//周一:埋头苦干，解决bug
        //  周五:今晚吃鸡
        //周二:请求大牛程序员帮忙
        //周六:与王婆介绍的小芳相亲
        //周三:今晚啤酒、龙虾、小烧烤
        //周日:郁郁寡欢、准备上班。
        //周四:主动帮助新来的女程序解决bug
        //周一:打牌
        System.out.println("请输入日期:");
        Scanner rs=new Scanner(System.in);
        for(;;){//设置了一个死循环，也可以使用while(true)来达到死循环效果
            String week=rs.next();
            if(week.equals("开摆"))//当输入“开摆”时，结束循环
                break;
            switch (week){//当输入的值不为“开摆”时，进入switch选择，从case:"周一"开始匹配，当匹配到时，输出对应语句，并结束当前选择，若直到default时仍未匹配到，则执行default并结束当前循环，注意每个case后必须加上break;否则会发生穿透现象(不再进行匹配，直接向下执行语句)
                case "周一":
                    System.out.println("打牌");
                    break;
                case "周二":
                    System.out.println("请求大牛程序员帮忙");
                    break;
                case "周三":
                    System.out.println("今晚啤酒、龙虾、小烧烤");
                    break;
                case "周四":
                    System.out.println("主动帮助新来的女程序解决bug");
                    break;
                case "周五":
                    System.out.println("今晚吃鸡");
                    break;
                case "周六":
                    System.out.println("与王婆介绍的小芳相亲");
                    break;
                case "周日":
                    System.out.println("郁郁寡欢、准备上班。");
                    break;
                default:
                    System.out.println("耍锤子耍，开摆！");
                    break;
            }
        }
    }
}

7、this指针–代表当前类的对象的地址

public class ThisDemo01 {
    String name="www";
    int id=1;
    public ThisDemo01() {//ThisDemo01的无参构造器
        this.id=5;//将当前类的成员变量id、name进行赋值
        this.name="qqq";
    }
    public static void main(String[] args) {
       new ThisDemo01();
       ThisDemo01 c=new ThisDemo01();
        System.out.println(c.id);//输出结果为5
    }
}

8、继承类：

public  class person {//person作为父类，可以被其他类继承，继承类称为person的子类，子类可以调用父类的公有方法和成员变量，但私有(private)成员变量和方法不能继承，因为实体类具有封装性，但后期通过Class.forName("xxx.class")反射可以强制打开权限，获取私有成员变量和调用私有方法
    private String name;
    private int age;
    public person() {
    }
    public person(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;
    }
}
//Teacher继承person
public class Teacher extends person{
    private int height;

    public Teacher() {
        super();
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}
public class Test {
    public static void main(String[] args) {
        Teacher teacher=new Teacher();
        person p=new person();
        teacher.setAge(1);//调用父类的公共方法setAge
        System.out.println(teacher.getAge());//输出为1
    }
}

10、多态：

1、多态:同一类型对象执行同一行为，会出现不同的行为特征

2、对于变量而言，编译看左，运行看左

//父类Animal
public abstract class Animal {
    public String name="动物nb";
    public abstract void run();
}
//子类dog
public class dog extends Animal{
    public String name="狗交了";
    @Override
    public void run() {//重写了父类的run方法
        System.out.println("🐕跑得快");
    }
}
//子类乌龟
public class wugui extends Animal{
    public String name="乌龟";
    @Override
    public void run() {
        System.out.println("乌龟跑不动");
    }
}
//测试类Test
public class Test {
    public static void main(String[] args) {
       /*
        dog d=new dog();
        d.run();
        wugui w=new wugui();
        w.run();普通方法
        */
        Animal a1=new dog();
        a1.run();//输出🐕跑得快
        //多态:同一类型对象执行同一行为，会出现不同的行为特征
        //编译看左，运行看右
        Animal a2=new wugui();
        a2.run();//输出乌龟跑不动
        System.out.println(a1.name);//对于成员变量而言，编译看左，运行看左
        System.out.println(a2.name);
    }
}

//接口USB
public interface USB {
     void jieru();
     void bachu();
}
//Computer类
public class Computer {
    private String name;
    public Computer(String name) {
        this.name = name;
    }
    public void installUSB(USB u){
        u.jieru();
        if(u instanceof jianpan){//先判断，再强转
            jianpan p=(jianpan) u;
             p.dazi();
        }else if(u instanceof Mouse){
            Mouse m=(Mouse) u;
            m.dianji();
        }
        u.bachu();
    }
    public void start(){
        System.out.println(name+"启动了");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//Mouse类作为USB接口的实现类
public class Mouse implements USB {
    private String name;
    @Override
    public void jieru() {
        System.out.println(name+"鼠标被接入了");
    }
    @Override
    public void bachu() {
        System.out.println(name+"鼠标被拔出了");
    }
    public void dianji(){
        System.out.println(name+"鼠标点击了");
    }
    public Mouse(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//jianpan类作为USB接口的实现类
public class jianpan implements USB{
    private String name;
    public jianpan(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void jieru() {
        System.out.println(name+"键盘被接入了");
    }
    @Override
    public void bachu() {
        System.out.println(name+"键盘被接入了");
    }
    public void dazi(){
        System.out.println(name+"键盘打字了");
    }
}
//Computer类
public class Computer {
    private String name;
    public Computer(String name) {
        this.name = name;
    }
    public void installUSB(USB u){
        u.jieru();//当test01类执行installUSB方法时，由于u实际为jianpan类对象(编译看左，运行看右)，所以当调用jieru()时，会执行其实现类jianpan的重写的jieru()方法，输出“外星人键盘被接入了”
        if(u instanceof jianpan){//判断u是否为jianpan类对象，之所以要判断，因为dazi和dianji这两个方法都属于jianpan和Mouse的独有方法，u不能调用，所以进行判断，然后强转，再调用自己独有的方法
            jianpan p=(jianpan) u;
             p.dazi();
        }else if(u instanceof Mouse){
            Mouse m=(Mouse) u;
            m.dianji();
        }
        u.bachu();
    }
    public void start(){
        System.out.println(name+"启动了");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//测试类
public class Test01 {
    public static void main(String[] args) {
      Computer s=new Computer("华为");//调用Computer类的构造器为其成员变量name赋值为“华为”
     s.start();//调用Computer类的start方法，输出“华为启动了”
     USB j=new jianpan("外星人");
     USB m=new Mouse("x100");
      s.installUSB(j);//调用方法，执行步骤看Computer类
      s.installUSB(m);
        //输出结果：
        华为启动了
外星人键盘被接入了
外星人键盘打字了
外星人键盘被接入了
x100鼠标被接入了
x100鼠标点击了
x100鼠标被拔出了
    }
}

11、接口interface：

1、接口中的所有抽象方法必须被子类重写，静态方法不会被重写，因为静态方法可以被共享.

2、接口中的方法可以不用加上abstract标志为抽象方法，但是如果不是抽象方法则必须加上标识符，比如static、default.