小白java基础关卡速通

2022-08-31  本文已影响0人  清明捉鬼

前言

特别基础，遗漏较多，在后期需要学习人员针对小标题知识点再过一遍
一段废话：
编程与哲学、数学是密不可分的，但是数学不好能不能学，当然能学，数学就是为了探索问题而存在，而编程是为了解决问题，二者相似，但是解决一个问题就像筑城，有很多角色，总得有不动脑的搬砖工，这个问题怎么解决不是你考虑得，你就是一搬砖的，根据当前的制度管理与欠薪数据显示写代码的跟干工地的很相似，工信部的发文也使用过IT民工这一称谓，一个筑的是真城，一个筑的是虚拟城，干个十年，你搬砖方法炉火纯青，一个砖有十八种搬法，恭喜你解决了一个了不起的问题：如何优雅的搬砖，这不是自嘲这是现状。另外入行后平时买点保健药，不然确实老的快，2年沧桑，5年油腻，十年秃头，电脑蓝光是不会骗人的。

java关键字

略;就是java语言的规则，关键字代表着某种秩序，后面会有编译器对其进行语法树的抽取之类的。

8种基础数据类型+字符串类型

boolean、byte、short、char、 double、 float、int、long 与 String
必须死记硬背，至于32位，8bit这种详细知识前期不作了解，会用就行

权限修饰符

private、public、protected、default(default不写)都是权限修饰符，一般放在类名、方法名、变量前面，java有且只有这四个权限修饰符，作用是为了限制访问范围，java里的访问范围主要是包与类、父与子的限制，java工程里要先建一个包（可以看作一个特殊文件夹），才能建各种类，包名为防止重复一般是 公司域名倒置为前缀+模块名+功能名，例： com.duck.gaga.eat、com.duck.gaga.drink

举个权限修饰符对包与类访问范围限制的例子：

包A 
   类1
     private 变量a
   类2
     protected 变量b
包B
   类3
     变量c
   类4
     public 变量d

1个包=n个类，1个类=n个方法+n个变量，类、方法、变量都可以设置被别人访问的权限，private只能是本类访问，so想操作变量a只能在类1里，变量d是public的是全局公开的，在类1、2、3都可以对变量d进行读取、修改之类的，后期自会理解深意，前期会用即可，default就是不写，譬如int i=0;没有权限修饰符，其实就是default，实战中除了protected其它比较常用，private存在的意义之一就是类里内部自用的方法尽量不要被外部看见，so用private修饰。

image.png
条件语句

当人嘲讽的时候顺口而出的就是，不就是if-else么有什么难得，说得就是这个条件语句，java条件分支语句共两种if-else、switch-case

if-else写法：

if(判断1){ //判断1一般我们称为表达式

}else if(判断2){

}else{

}

int n=0,j=1,e=3;
int i=1;
if(n>1){
  //n>1时走这个逻辑分支，其它分支自动跳过  
}else if(i==1){
  //i==1时走这个分支
  if(j<0){
     if(e>=3){
       //if语句可以嵌套，但是不宜过深嵌套过深会导致逻辑过于复杂
     }
  }
}else{
  //上述if都不匹配走这个else分支，else分支不是必须的，可以没有
}

有人问如果n>1,i==1的条件都符合怎么办？
答：if-else分支按照从上至下的顺序顺位执行，哪个条件先符合进入哪个分支，其它分支跳过，
譬如n=2，i=1时上述n>1的分支先进入，则其之后的i==1的逻辑分支就不会执行了，
switch-case：

switch(变量){
  case 常量值1：
    break;
  case 常量值2：
    break;
}

break是java的高频关键字，中断的意思，哪里都能写，万金油的角色，条件分支中代表着退出整个条件判断，如下写法1，
grade为'A'时，控制台输出“优秀”，退出整个switch判断。
grade为'B'时，控制台输出

上等
良好

因为'B'、'C'之间没有break；执行完'B'逻辑后，逻辑没有退出会往下顺序执行'C'的逻辑
为'C'时输出结果为“良好”，default是switch的语法，当所有条件不满足时会执行它这块逻辑，也可以省略，省略后代表当前分支逻辑没有缺省状况

      char grade = 'C';
//写法1(完整的)：
      switch(grade)
      {
         case 'A' :
            System.out.println("优秀"); 
            break;
         case 'B' :
            System.out.println("上等");
         case 'C' :
            System.out.println("良好");
            break;
         case 'D' :
         case 'E' :
            System.out.println("及格");
            break;
         case 'F' :
            System.out.println("你需要再努力努力");
            break;
         default :
            System.out.println("未知等级");
      }
//写法2（常用写法）：
int fee;
switch(fee){
  case 1:
     System.out.println("请支付1元");
  case 10:
     System.out.println("请支付10元");
     break;
  case 10000:
     System.out.println("您支付不起，请出门左转，记得关门么么哒！");
     break;
     
}
变量定义

语法固定格式：权限修饰符+数据类型+变量名，但是方法里的变量定义不使用权限修饰符（因为在后面的知识点会对变量进行分类，成员变量，静态变量之类的，已经约束了其使用范围，java的设计者就不会再对其进行修饰符的访问限定）

public void duckSay(){
 //这里的变量不用修饰符，会报错，它的使用范围是在当前方法内
 int i=4;
}

变量的定义是1.声明 2.赋值；可以先声明不赋具体值如private int fee;，在某个方法或者某个地方进行具体赋值，也可以连写在定义时就进行赋值private int fee = 5;

private int fee=5;
float miniFee=1.2f; //float数字后需加f表示浮点型
int[] oneFee={3,5}; //数组是特殊对象类型，学习完封装类后解锁
public static String = "天地玄宗，万炁本根";
java里的数据类型有如下几种：
1、8种数据类型
2、对象类型（在学习面向对象的知识后解锁这种类型知识）
static是关键字也是修饰符,作用是免去实例化，在学完面向对象的实例化知识后解锁，当前仅作了解
运算符

java里的运算符大致可分为：算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符
算数运算符：就是+-x% ++(自增运算符) --(自减运算符)
自增运算符：不用纠结++i还是i++这种问题，for循环打印出值时候自然就会了。

for(i=0;i<5;i++){
   int n=6;
   i++;
}

关系运算符：一般用于if语句里，==、!=、>、<、>=、<=小学数学。

int i=0;
if(i++>=3){
  //满足条件进入
}

位运算符：表层开发一般难以用到，忽略。
逻辑运算符：常用的为&&、||、!，一般用于if语句里，大致有&、&&、|、||、!。
&&称为“逻辑与”英文and的意思，||为“逻辑或”英文or的意思，!为“逻辑非”英文not得意思

if(i>3&&n<5){
  //两者都符合才进入
}
int k=5;
if(!k>5){
  //逻辑非就是对true、false取反的意思，此处对k>5进行取反意思为k<=5，故符合条件。
}

注意，!false的逻辑结果是true，逻辑假+逻辑假=逻辑真，真假为假，假真为假，真真为真，高中的知识，此处若看不懂没关系，一句话就是左边条件与右边条件共同作用产生的逻辑结果，写两行一眼就会。
问：&与&&有何区别？
答：&&具有短路的作用，譬如 if(n<1 && fee<50){}
左边的n若为false &&此时就会短路不会再判断右边逻辑即fee<50，但是&会再次判断造成计算资源浪费，||也类似具有短路功能。

三目运算符：固定格式:V=A>B?C:D,?与:是两个关键字符
三目运算符是对if else语句的简化，意思为 A>B?是的话V=C，否的话V=D。

//举例
int num1=5;
int num2=4;
int V;
int fee1=1;
int fee2=2;
V=num2>num1?fee1:fee2;//因为4<5，逻辑是假，所以取值fee2，故V的值为2

instanceof 运算符：这个运算符是java语言定义的关键字，作用就是判断对象是否相等，譬如，

int i=5;
if(i instanceof Integer){
  
}

此处结果为真i的值所对应的对象类型确实是int类型的封装类，封装类就是8种基础数据类型都对应着一个java对象，这些封装类专门服务于基础数据类型系列装箱拆箱操作或者其它辅助打杂的东西，具体可以搜java封装类

方法定义

说明：java里的方法就是C语言里的函数，称谓不同，用法也跟C语言相似
语法固定格式：权限修饰符 + 返回值类型 + 方法名(n个入参)

    public void computeFee(){
       //这里叫方法体
       computeFee2(100,5.8f);//这就是方法间的调用
    }   
    public void computeFee2(int i,float n){
        i=i+1;
        n=n+2;
    }

方法名后面用括号把入参括起来是固定写法，多个入参之间用英文逗号分割

循环语句

java得循环语句总共有三种while、do-while、for，for-each是for的增强版不算单独种类，自己择机而用，按照实际使用频率排序为for>while>>do-while,do-while实战至今我就见过一两次。

while：

int i=0
while(i>0) {
  //循环内容
  i++;
}

do-while:

do{
  //循环内容
}while(i>0);

while与do-while的区别是do-while功能=先走一遍循环内容+while的功能，会先走一遍循环的逻辑后再进行是否循环的逻辑判断，不符合就退出，所以出场率不高，while足矣。
for：

//写法1：
int fee;
for (int i = 0; i < 150; i++) {
    //循环体
    if (i > 100) {
      break;
    } else if (i > 80 && i < 100) {
      continue;
    }
    if (fee > 10000) {
      return;
    }
    fee = fee + 10;
}
//写法2为for的增强循环，基本是从数组或集合中取东西，此处略（集合java里是一种大小可变的特殊数组）

for一般写法就是下标循环，也就是示例的写法足以覆盖绝大部分业务。
问：循环怎么跳出来呢？
答：关键字break与return进行跳出整个循环，若只是想中断某一次循环的话用关键字continue,
这三者有啥区别？
break与continue的区别就是break是跳出当前整个循环逻辑，continue是跳出本次循环在continue后面的代码本次执行不到了，下一个循环再见，return是方法的返回值，方法一旦返回别说本次循环，是整个方法都跳出了，当方法返回值是void时写return;有具体返回值类型返回对应的类型值

int fee;
public int myFee() {
  for (int i = 0; i < 150; i++) {
     //循环体
     if (i > 100) {
       break;
     } else if (i > 80 && i < 100) {
       continue;
     }
     if (fee > 10000) {
       return fee;
     }
     fee = fee + 10;
   }
  return 0;
}
数组

数组在运行时是对象，写法上跟普通对象有些不一样，数组在内存中是一段连续的内存区域，所以在使用前需要定义好大小让系统去开辟内存，数组写的时候跟变量意义先声明再赋值也可以连写，在实际运行后就变成内存里的实体，大小不可更改，万物皆可数组，数组下标(index)从0开始，so数组中第1个元素的index=0,第2个元素index=1。数组可以理解为数据水桶，你要多少毫升的提前说好我铸造好了就没法改了。

几种写法格式，自己挑一种

//写法一：
float[] fee2 = new float[]{2.0f,3.4f,5.5f,3.2f};//表示声明一个float数组元素,
//此处没有声明容量，直接用元素填充了，元素具体值都有了，自然不用再赘述容量了
//写法二：
long[] fee3 ={3,5,29,67};//这是省略版写法，与fee2相同简化部分由编译器补全
//写法三：
AnObject[] obj = new AnObject[15];//一个类名叫AnObject的对象数组，容量为15
int[] fee1 = new int[10]//表示声明一个名为fee1的整型数组，元素储量为10，里面元素待添加，
//实战意义较大，因为实战中只需要声明水桶不需要数据，数据后续逻辑执行会添加
//赋值写法
fee1[0]=20;//表示在数组下标0这个地方赋值，值为20，
//取值写法
int myFee = fee1[0]//这个myFee值就是20.

下图是java语句，循环用的增强for循环即foreach，做数组练习足以，解出手机号为18013820100

苏宁豆芽图片20220901102210.png

上图代码等于

int[] arr = new int[]{8,2,1,0,3};
int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
String tel="";
for (int i = 0; i < index.length; i++) {
    tel=tel+arr[i];
}
System.out.println("联系方式为："+tel);

double k=1000.234;
int price = (int)k;//这就是强制类型转换的写法，四舍五入属于Math类的特殊算法需要使用Math类的方法
关于文字的封装类

Character是char的封装类，为char类型处理各种杂事，字符用单引号括起来书写为`F`,每个字符对应着Ascii编码.
练习题：对比字符串“a1sdcd3r%”相邻两个非数字字符的大小，并打印出对应的数字，提示->需要用到知识涉及：数组，for循环，字符串转字符数组,Character类（自己查询可用类里哪些方法）

String

String比较特殊，它是字符串不是基本数据类型是引用数据类型，它超高频很重要，典型的问法就是
String hai = new String("hellow!");产生了几个对象。
java中+号就可以实现类型转换和字符拼接。

int fee=500;
String priceList = fee+"";
String preffix = "价格清单："+priceList ;

+""是拼接一个空字符串的意思，我们在书写中经常在数字类型后面写这个以让结果转换为字符串，通常在for循环中字符串拼接。
StringBuffer (一般)线程安全的，可多线程使用，速度略低于StringBuilder；
StringBuilder(高频)线程不安全，单线程使用，速度快，一般都是它，多用于循环语句中的字符串追加拼接。
两者差别可百度“StringBuffer与StringBuilder”的区别

面向对象
固定语法格式：
数据类型 接收对象的变量名 = new 类名();
//1个类也是一个数据类型，除了8种基础数据类型外，我们写的类也是数据类型
LiuYiFei liuSir = new LiuYiFei();
这句话的意思是实例化一个刘亦菲并赋值给变量liuSir，这种赋值跟int oneChui=80;是差不多的意思
类：

java类有哪些概念
封装、继承、多态
划重点，这是面向对象的三大特性，是相对于面向过程的语言说的，这个很重要是java语言的立国之本，类在写的时候需要考虑这三大特性，故在此处才说。

//CarWL.java文件  五菱
public abstract class CarWL{
   public String name = "五菱系列";
}

//CarWLZG.java文件  五菱之光
public class CarWLZG extends CarWL{
   public int windowCount = 4;
   public int luntaiCount =3;
   private int ugly=100;
   public void drive(){
      System.out.println("敞着开");
   }
}
//CarWLHG .java文件  五菱宏光
public class CarWLHG extends CarWLZG{
   private String color = "#ffffffff";
}
//CarWLSG.java文件  五菱神光
public class CarWLSG extends CarWLHG {
   private int music = 5;
   @Override
   public void drive(){
      System.out.println("优雅的开");
   }
}

通过上面三个类可以发现，五菱宏光（CarWLHG）只定义了一个颜色，但实际上因为它继承自五菱之光（CarWLZG），所以它实际拥有了五菱宏光（CarWLHG）public修饰的部分，完整为windowCount 、luntaiCount 、color以及一个drive()方法 ，private修饰的东西无法被继承，所以丑就没被继承下来，有人问继承的东西能不能改动，当然可以，如上代码五菱神光（CarWLSG）这代就把开车方式给改了，以前都是敞着开到了神光这一代我就得优雅的开，这种改动涉及到一个java语法概念覆写又叫覆盖、重写，在方法上方加一个@Override关键字，表示对父类的方法进行方法体逻辑的重新定义。
总结：其实继承这个描述的本意我认为是将共性的东西向上抽取，动物->人->男人、女人，属于这种共性抽取的继承关系，越往下描述的越具体，源于生活却高于生活，这体现了一种由0到100的梯层设计，每一梯层都能满足一层的需求，这个需求其实就是做什么，定义对象的目的其实就是定义这个对象能做什么。

上述五菱的例子有这样一层继承关系
CarWLSG➼CarWLHG➼CarWLZG➼CarWL
//CarShow.java文件
public class CarShow{
  public void show(CarWL  carWl){
    System.out.println("展示五菱的车"+carWl.toString);
  }
}

//CarFactory.java
public class CarFactory{
  public void doAnCarShow(){
     //对象里方法的调用就是用  引用变量.方法
     CarShow carShow = new CarShow(); //实例化一个车展的对象（车展对象专门负责展示车）

     CarWL carWL = new CarWLSG(); //实例化一辆五菱神光，并用五菱车类型进行接收
     carShow.show(carWL); //车展对象做展出，展出的东西为五菱神光

     CarWL carWL = new CarWLZG();//实例化一辆五菱之光，并用五菱车类型进行接收
     carShow.show(carWL);  //车展对象做展出，展出的东西为五菱之光
  }
}

1.向上转型： 上述代码描述的就是多态的典型在代码里的实际运用， 将子类对象赋值给父类类型的变量,这种技术称为“向上转型”；
使用场景：有时候我们只知道要展示某一类型的车但不知道具体展示什么，那么我们就可以用这一类车的公用父类定义参数类型，这种场景在封装功能时经常会用到，但是向上转型后具体类型的特有属性就无了，譬如展示的之光用五菱类型去接收，那么它只剩下了name这一属性，只能对name这属性进行操作，其它属性都丢失了，因为CarWl没有CarWLZG的属性与方法，这个类型的变量只有carWl.name。
2.向下转型： 父类引用的对象转换为子类类型称为向下转型

//第一种：
CarWL carWL = new CarWLZG();//new1个五菱之光用五菱类接收
CarWLSG carWLSG = (CarWLSG)carWL;//强制转换为五菱神光
//第二种：
CarWL carWL = new CarWLSG();//new1个五菱神光用五菱类接收
CarWLSG carWLSG = (CarWLSG)carWL;//强制转换为五菱神光

上述两种都是向下转型，就是把父类对象强制类型转换为具体子类，譬如我定义一个五菱类型变量，由于五菱是五菱之光与五菱神光的父类，所以你传之光对象或者神光对象都行，我接收之后都转为神光，神光中有个music属性，我就用神光播放音乐，有人问这不是神经病么，不能直接传入神光么，因为我不知道后续会不会有类似神光这种五菱系列的车可以播放音乐，为了保持扩展性，在定义时我用共性的父类肯定没有问题，我的需求是播放音乐，如果车辆没有音乐功能，则它是一个缺省数据不影响我的功能，功能保持开放，选择归数据，这就是向下转型的作用，就是接收一个模糊的数据以备后用，这种也是封装功能的时候用的多。
总结：多态核心掌握就是向上转型，向下转型，有人问这种值不会丢失么，不管是向上转型还是向下转型都会丢失一些精度，这是正常的，那为什么还要这么用呢，因为数据操作本身都是目的性的，最差也有缺省值，所以实际使用中功能不会有啥影响，这一段到后期写一些泛型的封装自会理解。

public class LanApple{
   private int color;
   private int wide;
   private int high;
   public void changeColor(int color){
      System.out.println("颜色改为："+color);
   }
    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public int getWide() {
        return wide;
    }

    public void setWide(int wide) {
        this.wide = wide;
    }

    public int getHigh() {
        return high;
    }

    public void setHigh(int high) {
        this.high = high;
    }
}

这种就是一种封装，隐藏自身信息或实现细节，外部只能通过你定义的窗口进行访问无法直接操作，有人问我直接看源码不就都知道了，还能隐藏啥，干嘛不能直接访问变量，假使第三方公司给你一个sdk(软件开发工具包，都是编译后的字节码)不给源码只有访问的API（开放接口）这时候你就只能调用别人开放的接口，因为别人隐藏变量了信息，你不知道有啥可以拿，上述例子我改一下，把getHight改为panChangJiang,这个时候别人不知道你获取的是什么东西，你只能去查他写的解释，他不解释你永远不知道这是身高，你还以为是最小高度值，有序的告知防止人人知晓，晓得越少越安全。

public int panChangJiang() {
    return high;
}

再举个例子：

private BigFruitsBasket {
  private LanApple apple;
  private LanPear pear;
}
public class Gift {
  private BigFruitsBasket fruits;
  private DrinkBasket drink;
}

我定义好了一个送礼物的类，礼物有大水果篮子、饮料篮子，水果里有烂苹果跟烂梨子，我这时候想改一下礼物把烂梨子换成烂李子（plum），只需要改BigFruitsBasket ，Gift 就不用动，如果我不分类封装BigFruitsBasket这个类，把它这些水果写在Gift里面，礼物如果非常多，就会很容易改错而且不容易管理，我今天改水果，张三明天改饮料，每次修改礼物都要修改Gift，代码很容易改冲突，所以封装有句名言“高内聚，低耦合”这6个字就是封装的核心灵魂之一，在写的时候要想好一个功能可以拆分为几个对象，各个对象之间能做什么，怎么调用这种就是封装，模块化就是目的，模块与模块之前的关联越少越好就是低耦合，高内聚就是把功能越多越好的封装在自己内部。
1、封装有利于提高程序的安全性，保护数据
2、隐藏代码的实现细节，用户不可见
3、统一了接口
4、增加系统的可维护性

//People.java
public class LanApple{
  public void buy(){
    LanApple apple = new LanApple();
    LanApple apple2 = new LanApple("原谅色",50);
  }
}
//LanApple.java
public class LanApple{
  private String mColor;
  private int mWidth;
   public LanApple(){
      System.out.println("无参构造方法");
   }
   public LanApple(String color,int width){
      this.mColor=color;
      this.mWidth=width;
      System.out.println("双参构造方法");
   }
}

2.虚方法与非虚方法
静态方法、私有方法、final方法、构造方法、父类方法都是非虚方法，java中的普通方法都是虚方法可被子类覆写，在其它语言中譬如C#需要使用virtual关键字才有这个能力。
3.静态方法
在java中，静态方法指被static修饰的成员方法。静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用this关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。

4.抽象方法
5.方法的重载
6.方法的覆盖
有几种方法不能被重写：
1)静态方法：static修饰的方法，父类的静态方法不可以被重写，可以继承；
2)final修饰的方法：父类中final修饰的方法不可以被重写，可以被继承；
3)构造方法：父类的构造方法不可以被重写,也不需要覆写父类构造方法；
4)private修饰的：因为父类中private修饰的方法子类不可见；

public static int PEER_CONNECTION = 10;
public static int QINGDAO_BEER = 5;

类里面的内容怎么写

package com.book.testsourcecode;
public class AnJava {
   //写代码的地方
}
上一篇 下一篇

猜你喜欢

热点阅读