javaSE的基础学习01

JDK：java开发工具（包含着JRE 和JVM）

JRE:java运行时环境

JVM：java虚拟机

java是先编译后解释所以java即时编译型又是解释型

java也是一个强类型的语言就是要求先定义后才能使用

java的第一个代码

public class hello{
    public static void main(String[] args){
        System.out.print("Hello word !");
    }
}

数据类型
//整数的拓展 二进制0b 十进制 八进制0 十六进制0x
//字符的拓展 所有的字符本质都是数字
//低———————————————————————————————>高
//byte short char int long float double
//强制转换 (类型)变量名 从高到低需要转换
//自动转换            从低到高不需要转换
int i = 128
byte b = (byte)i;
//但是byte的区间在127~-127所以会内存溢出打印-1

变量作用域
//1类变量
//2实例变量
//3局部变量
//一个类里面只有一个main 但是可以有多个函数像void等
public class A {
    static int salary = 2500;  //类变量
    String name;  //实例变量
    
    public static void main(String[] args){
        int i = 10;    //局部变量
        //变量类型 变量名字 = new A()调用自己
        A a = new A();//这里调用实例变量方法是new一个class类后面变量名然后点击提示就会自动给你写好然后就可以调用实例变量
        System.out.println(a.name);
        System.out.println(i);
        System.out.println(salary);//调用类变量直接调用
    }
常量
//常量:一般都是大写的  final 常量名 = 值  final 是修饰符不存在先后顺序(public 公有的修饰符)
    static final int MONEY = 100;

三元运算符

int score = 50;
String type = score < 60 ?"不及格"："及格"；
补充：<<左移  *2
	>>右移  /2

equals：比较字符串是否相等

用法：要比较的对象.equals("要比较的对象")例子：s.equals("1000")

return：结束方法，返回一个结果！

//switch循环架构
switch(){
case "输入条件":
        brake;
default:

}
 
//do while循环
do{
    //代码部分,先执行在判断
}while(布尔表达式);

//增强for循环
// 数据类型 被重新赋值的    变量
for( int       x      :   num)
{
    //代码
}

方法：java方法是语句的集合，简化代码

方法的重载：就是在被调用那里多写一个被调用的方法

数组：

//数组
int[] num;//定义数组
nums = new int[10];//创建一个数组
System.out.println(Arrays.toString(nums));//打印数组

稀疏数组原理就是：给了一大张全零矩阵，把含有数值的地方通过行列值来表示，大大简化了代码空间

面向对象编程

面向对象编成的本质是:以类的方式组织代码，以对象的组织（封装）数据

public class Deom1 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//1
        Deom1.num(a);//虽然调用了num但是是值传递，仅仅把值留给了num
        System.out.println(a);//1

    }
    public static void num (int a){
         a = 10;//要是引用传递这里就是 a.对象 那样就会改变值了，因为对象是指向一个具体的东西
        System.out.println(a);//10
    }
}
//打印结果是 1 10 1

对象是具体的事物（我是这样理解的，对象就是在一个文件中写好了的方法，在另一个文件中想要调用它从而简化代码的复用性提高代码使用效率）

使用new关键字创建对象

idea 快捷键 alt insert 调用构造器

构造器：初始化对象的值，new的本质就是在调用构造器 this是关键字 this是本身调用者的对象

注意：定义有参构造后，如果想使用无参构造，显式定义一个无参的构造

类是抽象的类是对象的模板类里面只允许有这两个

1静态的属性（属性）：字段例如： String name；这就是属性

2动态的方法（方法）：公有私有等例如：public void num()

类里面只允许有这两个

封装

提高程序安全性，保护数据（就是不让人轻易拿到接口，统一接口他也方便）
隐藏代码的实现系统维护得到增加

面对private（私有）我们无法拿到值所以public提供了一些方法 get set这是两个人的游戏首先是一个定义好的一个私有属性例如：

public class Demo2 {
        private String name;//私有变量
        private int id;
        //快捷键alt insert
        public String getname(){//设置getname
        return this.name;
    }
        public void setname(String name){
        this.name = name;//有关setname的一切逻辑都是由这里来完成的Demo3仅仅是调用我们为了他那里面简洁，所以要加什么判断逻辑在这里加
    }
}
//这是设置set和get

public class Demo3 {
    public static void main(String[] args) {
    //修饰符 属性类型 属性名 = 属性值
      Demo2 s1 = new Demo2();//调用Demo2的对象
      s1.setname("wangkai");//这里传的参数是Demo2里的String name传给他
        System.out.println(s1.getname());//打印调用了getname这个方法
    }
}
//这是主函数

继承

是对类的抽象，再次建模主推extends 扩展，子类是父类的扩展注意：私有的无法被继承其实就这几点东西（ctrl + h 打开方法父类）

子类继承父类可以有父类的全部方法，所以子类是父类的扩展
同时子类也更加灵活，如果不满足父类的方法，它可以用重写的方法来改造
super 是表示父类对象的应用（相当于象征）调用父类的构造器必须在子类构造器的第一行执行，这时this的构造器就不能和他同时出现（他俩只能活一个）注意：super只能用在继承条件下

重写

重写就简单易一点，首先他必须在继承关系当中子类重写父类的方法，其次方法名要相同（就是要静态全静态，要非静态就全非静态提示：一般都是非静态）例如：父类是这样的 public static demo（）{}子类也是这样它们的区别在里面大括号里面是不同的

多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式，这个也很好理解举个例子

Student s1 = new Student();//这就是多态，
Person s2 = new Student();//这调用了父类
Object s3 = new Student();//这是所用的父类
//就是不同的引用类型都可以来指向这个属性值

接口：可以实现多继承类只能是单继承

接口中所有定义的方法其实都是抽象的是public abstract

异常

try{
    //try的监控区这里面写要监控的代码
}catch(这里面填写想要捕获的异常类型){
    //catch可以有多个但是要层层递进把最大的放到最后
}finally{
    //他其实可以没有，它属于善后的，不管catch报没报错它都会执行
}