java基础

java 发展史  sum公司   创始人  詹姆斯-高斯林

java 8.0 公司中使用的最多

java跨平台原理

java 语言  通过 jvm 虚拟机  向不同的 平台发布东西  实现跨平台原理  

win版 jvm  mac 版jvm  linux 版jvm

jdk jre jvm 关系

jdk 用来开发的  jdk包含jer  ,  jre就是运行环境  

jdk中(javac 用来编译   java 用来运行)=====>编译后运行的虚拟机jvm

jre(包含 jvm  跟核心类库(类))  总结 我们只需要jdk 就够了

jdk库

www.Oracle.com 甲骨文中文网

Doc命令

cd 文件名   (进入)   cd..  返回上一级    cd / 返回根目录    cls  清除dos窗口

注释

// 单行注释  

/* 文本 */ 多行注释

/** 文本 */ 文档注释

关键字

plublc  class  类名 {

        public void main String([] args){

        }

}

常量

整数, 小数 , 字符串("双引号包裹的") ,字符('单引号包裹的') , 布尔 , 空常量  

空常量 是不能直接输出的(记住)

数据类型

基本数据类型

数值型 ===>  byte  short  int   long  (整数)    float   double    (浮点数)     char(字符)   String  字符串 

引用数据类型

class 类   interface  接口    [] 数组   Object 对象

变量

System.out....("20")=====>System.out....("10")

System.out....("20")====>System.out....("10")

System.out....("20")=====》System.out....("10")

上面这样变换的时候  ====》 很麻烦  有没有一个 位置可以保存这个值 

暂存位置 就是 变量  变量存放在  内存里面====》

变量  就是内存的一小块 地方 （开辟空间）

整数 默认 是 int 类型的  小数默认是 double 类型的    

变量的应用

这个位置  必须有 名字  ，  数据类型  ，  具体的值  

数据类型  名字   =  值  //声明变量  

名字 = 值；//变量的修改

默认类型的修改

long   再数后 加 L   float  数后面 加  F

标识符

1.由数字 字母  下划线   和  $ 符号组成

2.不能由数字开头 

3.区分大小写

4.不能是关键字

驼峰命名法

第一个单词的 首字母小写  其他的首字母大写

byte===》short===》int ====》long===》float ====》double  自然转换 小到大没问题

char===》int===》float===》long====》double  自然转换 小到大没问题

从大到小 ====》需要强制转换  （类型）  不推荐===>会有数据丢失

算数运算符

 最基本的  加 减 乘 除 取余   

除===》得到的是商  （要想得到小数必须是 double 小数型）否则就是整数

取余 得到的是余数   6/4  余数是 2

字符加操作

字符 ‘单引号包裹的’  

字符 进行加减运算的时候 是把字符转换成计算机底层的 数字进行加减 

char a = ‘c’+1//这个写法不对  当一个运算表达式出现多种类型的时候 这个表达式的类型会被整体提升  位表达式里面有的最高数据类型  

int a = 'c'  +1  就可以运行//这里面的最高数据类型 是 int 的数据类型

字符串加操作

字符串 + 数字 都是字符串的拼接   

字符串后面的是 字符拼接 ===》 ”我“+111=我111

字符串前面的数字  加 是  先运算 后拼接   ===》1+99+我 = 100 我

扩展的运算符

short a =10//  含义是 将10 这个值 赋值 给 short 类型的 a

扩展运算符号 隐含了(类型提升数字默认是int)强制转换===》他会出现无法运算 有可能会数据类型整体提升 ===》

可以用 （数据类型）（转换的式子）===》强制转换

自增自减运算符

自增,自减在前 先自增 或自减 再赋值,

自增自减在后 先赋值 再自减自增

逻辑运算符

& 与  | 或  ! 非  ^异或

&与  有false 则false

false $ false ==>false

false $ true==>false

true $ false ==>false

true $ true ==>true

| 或 有true 则true

false $ false ==>false

false $ true==>true

true $ false ==>true

true $ true ==>true

^异或 相同则是false 不同则是true

false $ false ==>false

false $ true==>true

true $ false ==>true

true $ true ==>false

! 非 相反值

false ===>!false ====>true

true====>!true====>false

短路逻辑运算符

int i =10

int j =20

输出(i++>100&&j++>100)===>false&&false===>false 短路与

输出(i,j)===>i=11  j= 20  短路与 如果左边是false 右边不执行

输出(i++>100&j++>100)===>false&&false===>false

输出(i,j)==>i=11,j=21

短路与 左边是false  右边不执行  

短路或 左边是 true 右边不执行

三元运算符

表达式 对执行左边错执行右边? 左边值:右边值 

Scanner  接收器

首先导包 import java.util.Scanner

Scanner scanner = new Scanner(System.in)

scanner.nextin()//定义好输入的是  啥类型的

顺序结构

选择行业 ===>到底走那条行业的路===>最终选择java

电风扇 为啥挥动 ====>循环重复的旋转

代码 从上往下 ===>顺序结构

if条件分支

if(表达式){

        执行语句

}

不会影响后续的

1.练习====>判断输入的是技术还是偶数

多条件分支====>  多个

第36集

switch 语句

switch(){

case 值:........

        语句体

break;

default:

        执行语句体

}        

case====>比较  值用来

break;跳出当前的语句 中断执行语句

default;表示没有符合的语句 默认执行的一句 默认值

case 有穿透 没有break 就会一直执行下去  但是也有好处 比如多个 值相同的答案情况下 

case:1

case:2

case:3

 System.out.prinlt("输出语句")   这样 1,2,3===>都是执行这一句   (春夏秋冬案例)

循环语句 for

for(初始化语句;条件判断;条件控制){

如果条件 ===>true 执行  false  ====>不执行

}

水仙花数

for (int i =100;i<=999;i++){
            //条件 是一个三位数
            //条件 百位数 的3次方+十位数三次方+个位数三次方= 数 的本身
            //371 ===>个位数  371%10
            //371====> 371/100 整除
            //371====>371/10===>37%10===>得到十位数
            int g = i%10;//个
            int b = i/100;//百
            int s = (i/10)%10;//十
            if(g*g*g+b*b*b+s*s*s==i){
                System.out.println("水仙花数"+i);
            }
        }

while  循环

while(判断条件){

        代码控制再这里面

        代码执行体  

},

案例 珠穆朗玛峰

//单位是毫米
        double i =0.1;//纸张的厚度
        int count =0;//折叠的次数
        //珠穆朗玛峰  为 8844430毫米
        while (i<=8844430){
            count++;
            i*=2;
            System.out.println("当前为"+i+"毫米");
        }
        System.out.println("折叠的次数为"+count);

do  while 循环

do {

循环体执行代码

循环控制

}while(判断是否执行继续)

最常用的 死循环 是while死循环   cmd 里面 按 Ctrl+c是终止死循环

控制循环的 关键字

break //到达什么条件 终止 这个循环

continue//跳出当前 循环 继续执行代码体

return //终止当前循环  并返回结果

循环嵌套

各种语句 嵌套   任何一种语句都可以看成  一个输出 简单的语句 

所以可以循环 或者 条件嵌套使用 

循环 渐进代码

        输出(0时0分)

        输出(0时1分)

        输出(0时2分)

        输出(1时0分)

        输出(1时1分)

        输出(1时2分)

        输出(2时0分)

        输出(2时1分)

        输出(2时2分)

上面的 多个条 依次执行  ====>  可以改编成  用for循环执行的语句  双重for循环

案例====> 小时 ====>分钟 每个小时 输出  60 个分钟

random 随机数

         Random r =new Random();
        int random = r.nextInt(10);
        System.out.println(random);

随机数 ===>nextInt(数值)===>包含0  但是不包含你设置的这个数

猜数字案例

Idea 快捷键 辅助键

ctrl + Alt + space ===>代码提示 再次出现

ctrl + Alt + L  代码重新排版

删除 创建 模块 ===>可以创建多个模块

数组 动态初始化

int [] arr = {1,2,3,4} 数组的声明  直接声明 好数组里面有几个

数组数据初始化 就是赋值

动态初始化数组

int [] arr = new int [11]//初始化了数组的长度

 public static void main(String[] args) {
        int [] arr = {1,2,3,4};
        System.out.println(arr);
        int [] arr2 =new int[11];
        /*
        * int数组的类型
        * []说明这是数组
        * arr2数组的名称
        * new 开辟新空间
        * int 类型
        * [11]数组的长度
        * */
        System.out.println(arr2.length);
    }

数组的访问

索引 访问 数组[suoyin] 就是访问  

数组[索引]=值  ====>赋值

java的内存分配

数组的内存分配  new  就是开辟新空间  再开辟新空间后 会给数组默认赋值===>

int 类型的是  0

boolean 类型的是 false

double 是0.0

字符:默认是空字符

引用类型默认是 null

先指向地址  ==>从0-n依次找

 堆内存===> new 出来的实体 存放在 堆里面 然后 使用后会再垃圾回收器空闲时间自动回收

 栈内存===> 等号左边的 定义的变量 存放在栈内存里面 存储的是局部变量 使用完毕 立即消失

数组的单个赋值

 创建 数组arr   直到把 001 地址赋值给arr 完成第一步

数组是引用类型 输出的是地址一个 

多个数组指向同一个地址

声明好了一个 数组 后  采取等于 的方式 赋值  比如  arr1  = arr2  

是  arr2把 自己的地址 给了 arr1  修改 arr1的每个值  arr2的 值 也会发生改变 因为是同意个地址

数组静态初始化

int [] arr = new int []{值,值}

int [] arr2 = {值,值,值}

数组常见的问题

如果数组 长度 没有 我们想要的索引值   就会出现 索引越界问题

访问的数组  是通过地址 访问的 如果地址 赋值 为了null  就找不到这个地址了  如果强行访问就会空指针异常

方法创建

public static void main(String[] args) {
        addUser();
        comper(10,21);
    }
    public static void addUser(){
        System.out.println("我是添加用户");
    }
    public static void comper(int num1,int num2){
        //比较大小
        if(num1>num2){
            System.out.println("num1大于num2");
        }else {
            System.out.println("num2大于num1");
        }
    }

方法的传参===>上面写的是什么类型的  你就要传递什么类型的 有几个参数 就要传递几个参数

 public static int adduser(){
        /**
         * 增加用户 方法 只要有返回值  必须 void 变成跟返回的类型相同的类型 
         * 否则代码就会报错  return 的值 类型 === 方法的类型 void 是无返回值
         * 
         * */
        
        return 10;
    }

return 的是给了方法  ===>我们需要用相对的变量 负责接收他 也要用相对的类型 接收

if  跟 else 里面 都需要 写相对的 返回值

return  的就是 方法  =====>

方法的重载

当 创建的 方法名相同  参数或者 参数个数都不相同时  就是方法的重载  

方法的重载 跟返回值类型 没有关系

面向对象的类跟对象

类==>他是泛指 广泛事物中 有相同属性的一类东西   比如手机 手机都有属性 方法 

属性  型号 像素  版本 等  行为  打电话 玩游戏  发短信 都是手机这一类常有的公共方法

对象===>他是指 再广泛的一类中特别指 的某个对象 ===>比如说 这个小米手机 

针对性的指 这个小米手机 ===>我们 开发的时候 就是面向对象开发 我们不需要知道 

手机怎么做出来的我们只需要会用就好了  

创建一个学生类 并使用它

package 类对象;

public class Student {//学生类
    //属性
    String name;//名字
    int age;//年龄
    String hobby;//爱好
    //行为方法
    public void play(){
        System.out.println("我会玩");
    }
    public void eat(){
        System.out.println("我会吃");
    }
}




package 类对象;使用 这个类

public class 创建学生类 {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name="卢贝";
        stu.age=24;
        System.out.println(stu.name);
        System.out.println(stu.age);
        stu.play();
        stu.eat();
    }
}

单个 对象解说

比如上面的 学生类  我要再 main方法中 调用 学生类 

一开始 我们的main方法 加载到 栈内存中去  然后 Student  stu 再 栈内存中 里面有个地址指向 

new  student()  再 堆内存中 堆内存里面有 相关的  Student的对象的相关属性并且有默认值

如果 调用 stu.的方法()=====>这个方法执行===>进入 栈中当执行完方法后  消失  剩下的方法依次一样  ====>最后所有的方法都执行完毕后 ===>main方法 才会再栈内存中消失

栈内存中的 方法 只要执行完毕后 就会立即消失掉 

堆内存中的方法 不会 他需要等垃圾回收器来回收他

指向的地址 是一样 就相当于修改的相同的 地址的数值

成员变量 跟局部变量

成员变量===又叫全局变量

类中位置 不同 成员变量 是类中 方法外   局部变量是 方法内或者方法的声明上

内存中位置不一样  成员变量 再堆内存里面    局部变量 再 栈内存里面

生命周期不同   随着对象的存在而存在 对象的消失而消失   局部变量是随着方法的调用而存在方放的结束而消失 

初始化值不一样   成员变量有默认的初始化值       局部变量没有默认的初始化值必须先定义赋值,才能使用

封装

封装 里面需要 有 private 这个关键字 他是 变量 私有化 

加了这个关键字的变量 只能这个类中的 方法访问这个变量 或者修改  可以在方法中写判断

看看 是否是否符格式

我们可以再 类中 创建 私有的方法  ===>就修改访问我们类中的 私有属性

package 类对象;

public class iphone {//手机类封装
    private String name;
    private int age;

    public void setName(String a){
        name=a;
    }
    public void setAge(int b){
        age=b;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

不可以 用相同的参数名字  如果重名了 可以使用 this.来解决冲名字的问题例如

package 类对象;

public class iphone {//手机类封装
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

this关键字

this.修饰的 变量名字 指代的是 成员变量  

局部变量 与 成员变量 相同时 ==>方法里面的 name  指的是  局部变量

当方法上 没有 局部变量的 时候 return 的变量  指的就是 成员变量  

this.就是用来 解决 局部变量 隐藏 成员变量的问题

再  经过 类 创建 对象 的时候 main 方法 进入 栈中 ===>new student  进入 堆中 

创建对象  会生成一个地址 ===>001   

每一个  set方法里面的 this  指向的就是 创建的对象的地址  

封装

封装  是 对客观事物的模拟  外部是无法直接访问的

封装的原则  不允许 外部访问 想要修改 内部的成员变量 必须通过 自己的set  get 方法 来修改

封装的好处 通过方法来控制成员变量 提高了代码的安全性  

把代码 用方法进行封装 提高代码的复用性

构造函数

构造函数 ===>public   类名 (){

                这是 无参构造函数

        }

构造函数  默认只要创建对象 就 自动调用

每一个类 都默认有一个 构造函数 ===>但是当 我们创建了 有参构造函数后 我们想要调用 无参数的构造函数 我们就需要 自己 手写了

再 创建对象的 时候  new Student()==>调用无参的构造方法  

new  Studengt("卢贝")====>调用有参的构造方法

如果 定义了 构造方法 系统就不再提供 方法 

标准类的制作 !!!!!

public  类 {

private  String name ;

private  int  age ;

        public 类名 (){

        

}

get方法 

set 方法

}

继承

多态