荐 第二天学习Java的内容

建议新手观看，大佬勿喷，个人理解

今天先来学习一下变量跟常量

变量 : 顾名思义就是会改变的量。代码贴下面

int a=1; //这就是一个变量

变量又分为全局变量，局部变量，这有上面区别？代码展示

  int a=1; //全局
    public void jubu(){
     int b =1; //局部变量
    }

全局变量顾名思义就是这个变量我们都可以拿得到，而局部变量只存在当前方法中，只有当前方法能使用
常量： 可以理解成它是一个固定的数据，用关键字：final修饰，代码展示以下更清楚

final int FINALS_INT=1;

常量必须用final修饰，且常量名全为大写，值为固定不能修改

方法

Java中的方法你可以理解为它是一种饮料，因为包装不同，味道也不同，也就是说每种方法中都有不同的实现
方法由访问修饰符 返回值类型 方法名 方法体组成

• 有返回值

 //方法由访问修饰符  返回值类型 方法名 方法体组成
 public String xiaoHua(){
		 //方法体
        return  null;
    }
    public int  xiaoMing(){
   	 //方法体
        return 0;
    }
    public  Object object(){
  		  //方法体
        return  new Object();
    }

科普以下访问修饰符有哪些

• public 意思是公开的，整个项目都可以访问public修饰的属性跟方法
• protected 意思是受保护的，同包及子类可以访问
• default 意思默认的 同胞可以访问
• private 意思就是私有的 只有当前类可以访问

返回值类型有哪些？

• 8大基本数据类型
• 引用数据类型
• ps：java只有这两种数据类型

-无返回值
由void修饰的都是无返回值的

 //方法由访问修饰符  返回值类型 方法名 方法体组成
    public void jubu(){
		//方法体
    }

方法中可以带几个参数？
答：可以传你想要传的参数类型，不受限制

 //方法由访问修饰符  返回值类型 方法名 方法体组成
    public void jubu(int a,int b,int c){

    }
   

同用类型的话 你不想写多个的话可以直接这样写

 public void jubu(int...params){

    }

这个表示你传的数据类型是int 可以传多个，它是以数组的形式储存

那有的人又说了，方法名相同可以吗？
答 ：这个是可以的，不过前提是方法的参数不能一样，这样叫做方法的重载

 //方法由访问修饰符  返回值类型 方法名 方法体组成
    public void jubu(int a){

    }
    public void jubu(int a,int b){

    }

我想了想，String必须看以下源码的equals
PS：大家记住了String是lang包下的，且是被final修饰的
代码如下：

public boolean equals(Object anObject) {
			//比较地址
        if (this == anObject) {
            return true;
        }
        //判断该对象是不是String
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            //比较当前的长度跟穿过来的长度
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                //比较每一个字符是否相同
                    if (v1[i] != v2[i])
                    //不同返回fasle
                        return false;
                    i++;
                }
                //否则返回true
                return true;
            }
        }
        //比较当前地址不同的话直接返回false
        return false;
    }

• 与其他equals不一样的是String重写了equals的方法

注意一个问题：hashcode相同equals不一定相同，equals相同 hashcode一定相同

Java的三大特征是：封装，继承，多态，(抽象)

• 封装： 简单来说把对象的属性进行set 和get的操作，提供外界访问用的。
• 概念：面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个类中，有些属性是不希望公开的，或者说被其他对象访问的，所以我们使用private修饰该属性，使其隐藏起来；类中提供了方法（用public修饰），常用的是get、set方法，可以操作这些被隐藏的属性，其他类可以通过调用这些方法，改变隐藏属性的值！
  继承： 简单来说就是子类继承父类的所有属性和方法，除了私有方法。
• 概念：定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，使用extends关键字实现继承；子类中可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
• 多态： 简单来说多态的体现在重载，重写更为明显，多发生在继承关系上。
• 概念:多态就是在声明时使用父类，在实现或调用时使用具体的子类；即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性，多态增强了软件的灵活性和扩展性。这里可以举个例子，比如声明时使用的是动物类，调用时传递的是一个猫类（动物类的子类）的对象，具体执行父类里动物——吃的方法时，实际执行的是猫——吃的方法

自己去理解！加油！加油！

封装代码展示：

public class User {

    private  String name; //用户名
    private  int 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;
    }
	//这是有参的构造函数
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
  //这是无参的构造函数，如果没写有参的  默认是有的，如果写了有参的  无参记得也要写
    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

无参的构造函数，如果没写有参的 默认是有的，如果写了有参的 无参记得也要写

继承代码展示：
我们使用继承上面的User类

/**
 * 猫类
 */
public class Cat  extends User{
     private  String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public  Cat(){
        
    }
    public  Cat(String sex){
        this.sex=sex;
    }

有上面发现上面？这边居然可以点到User的封装的方法，这就是继承！！！！！

多态代码展示：
我们在User中添加一个方法

 public  String  jiao(){
        return "叫";
    }

然后可以在Cat类中重写一个jiao()的方法

    @Override
    public String jiao() {
        return "狗叫";
    }

多态就是这样子，自己多去练练

现在来讲一讲Java的类型转化

类型转化分为：显示转化和隐式转化
显示转化：就是大的类型转化为小的过程，看字节，越大的就是大
隐式转化：就是小的类型转化为大的过程

• 这样理解会好一点：你就看做是一瓶饮料，容量不一样，大的要倒进小的，倒不完，所以要强制转化，会丢失精度，但你小的要倒进大的 绰绰有余注意float比int大。

代码展示

	    float f= 2.2f;
        int  i = 4;
        int i1 =(int)f+i;
        //低的可以隐式自己转化
        double d1 =i+f;
        System.out.println(i1);
        System.out.println(d1);

这里给你们留下这个问题：为什么会出现6.19999999…

Java内存分配的问题

栈(Stack) 存放的都是局部变量(定义在方法内部或者方法参数上的参数)，局部变量都有自己的作用域，一旦超出作用域会立即从栈内存中消失。方法的运行一定在栈中，运行某个方法会把这个方法压入栈中，一旦运行结束即从栈中弹出该方法。
堆(Heap)： 只要是new出来的东西(成员属性、成员方法等等)都在堆中。堆里面存放的都系都有一个地址值

• 这个先自己理解以下，到后面专门详解

| and & 的关系

• | and &：按位或和按位与，将数据转换为二进制后计算。
  || and &&：按位或和按位与(存在短路原则)，将数据转换为二进制后计算。

继续更新 现在2020年7月11日 15点51分，请关注下一篇博客

本文地址：https://blog.csdn.net/xiaoyanghnl/article/details/107279355