java进阶编程思想（七天）

最新推荐文章于 2024-08-27 11:00:05 发布
最新推荐文章于 2024-08-27 11:00:05 发布
阅读量54 收藏
点赞数
分类专栏： 面试 学习路线 阿里巴巴资料职业发展 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74823408/article/details/133765004
版权
编程核心思想

b站链接:懂不懂我意思明不明白哈哈哈

基本框架

1.先建一个空项目
2.建一个新模块
3.建一个包
4.建一个class类

类中五大成份：
成员变量Field、成员方法Method、构造器Constructor、代码块、内部分
构造器：初始化一个类的对象并返回引用·
格式：修饰符 类名（形参）{ }
初始化对象格式：类名 对象名称=new 构造器；

this关键字：代表当前对象的引用
可以用在实例化方法和构造器中
用在方法中，谁调用这个方法，this就代表谁
用在构造器，代表构造器正在初始化的那个对象的引用

知识点：
1：封装
提高安全性
实现代码组件化
成员变量私有：用private修饰
成套的getter+setter方法暴露成员变量的取值和赋值，piblic修饰符公开

2：this关键字
3：static关键字
静态成员变量、实例成员变量
静态方法、实例方法

package com._01;

public class ClassDemo01 {
    public static String schoolName="黑马";
    private String name;
    private int age;

    public static void main(String[] args){
        System.out.println(ClassDemo01.schoolName);
        ClassDemo01 swk=new ClassDemo01();
        swk.name="孙悟空";
        System.out.println(swk.name);
        System.out.println(swk.age);
        System.out.println(swk.schoolName);
    }
}

4: 继承
5：多态

第一天（继承）

方法访问

package com._01;

public class ClassDemo2 {
    private String name;
    private int age;
    public static void inAddr(){
        System.out.println("搞学习");
    }
    public void eat(){
        System.out.println(name+"已经"+age+"岁。在吃好吃的");
    }
    public static void main(String[] args){
        ClassDemo2.inAddr();
        inAddr();//在同一个类中访问静态成员可以省略不写

        //对象 实例化
        ClassDemo2 zbj=new ClassDemo2();
        zbj.name="八戒";
        zbj.age=1000;
        zbj.eat();

        zbj.inAddr();//不推荐
    }
}

继承
在这里插入图片描述

public class dome1 {
    public static void main(String[] args){
        Cat c=new  Cat();
    }
}
class Cat extends Animal{
}
class Animal{
    public String name;
    public void run(){

    }
}

子类可以继承父类私有成员，但是不能访问

public class dome1 {
    public static void main(String[] args){
        Cat c=new  Cat();
        Cat.test();
        System.out.println(Cat.schoolName);
    }
}
class Cat extends Animal{
}
class Animal{
    public static String schoolName="黑马";
    public static void test(){

    }
    public void run(){

    }
}

方法重写

public class dome1 {
    public static void main(String[] args){
        Cat c=new  Cat();
        c.run();
    }
}
class Cat extends Animal{
    @Override   //校验注解，写错会报错，安全
    public void run(){
        System.out.println("跑的贼快");
    }
}
class Animal{
    public void run(){
    System.out.println("动物可以跑步");
    }
}

super调用父类被重写

public class dome1 {
    public static void main(String[] args){
        Cat c=new  Cat();
        c.go();
    }
}
class Cat extends Animal{
    @Override   //校验注解，写错会报错，安全
    public void run(){
        System.out.println("跑的贼快");
    }
    public void go(){
        super.run();
        run();
    }
}
class Animal{
    public void run(){
    System.out.println("动物可以跑步");
    }
}

静态方法和私有方法都不可被重写
继承后构造器的特点
在这里插入图片描述
在这里插入图片描述
this和super关键字
在这里插入图片描述
在这里插入图片描述
继承特点
在这里插入图片描述
3.一个类可以有多个子类
4.一个类要么继承了object类，要么简接继承了object类，是java中祖宗类
引用类
在这里插入图片描述
在这里插入图片描述

第二天（抽象和接口）

抽象类定义

public class dome1 {
    public static void main(String[] args){
      
    }
}
class Dog extends Animal{
    @Override   //校验注解，写错会报错，安全
    public void run(){
        System.out.println("跑的贼快");
    }
}
class Cat extends Animal{
    @Override   //校验注解，写错会报错，安全
    public void run(){
        System.out.println("跑的贼快");
    }
}
 abstract class Animal{
    public abstract void run();
}

在这里插入图片描述
抽象类使用

package Demo1;

public class demo1 {
    public static void main(String[] args){
        Teacher a=new Teacher();
        a.work();
        Manage b=new Manage();
        b.work();
    }

}
class Manage extends Employee{
    @Override
    public void work(){
        System.out.println("管理");
    }
}

class Teacher extends Employee{
    @Override
    public void work(){
        System.out.println("讲课");
    }
}

abstract class Employee{
    public abstract void work();
}

在这里插入图片描述
抽象类特征
在这里插入图片描述
抽象类存在意义

package Demo1;

import com.sun.org.apache.xalan.internal.xsltc.compiler.Template;
public class demo1{
    public static void main(String[] args){
        Student lty=new Student();
        lty.write();

        Teacher t=new Teacher();
        t.write();
    }
}
class Teacher extends demo2{
    @Override
    public String writeMain(){
        return "		cucjb";
    }
}
class Student extends demo2{
    @Override
    public String writeMain(){
        return "		cucjb";
    }
}
abstract class demo2 {
    private String title="wdbbb1";
    private String one="wdbbb1";
    private String last="wdbbb1";
    public  void write(){
        System.out.println(title);
        System.out.println(one);
        System.out.println(writeMain());
        System.out.println(last);
    }
    public abstract String writeMain();
}

在这里插入图片描述
接口
在这里插入图片描述
在这里插入图片描述
接口多实现

package Demo1;

public class demo1{
   public static void main(String[] args){
Basketball yao=new Basketball();
yao.rule();
yao.competition();
yao.run();
   }
}
class Basketball implements SportMan,Law{
@Override
   public void run(){

}
   @Override
   public void competition(){

   }
   @Override
   public void rule(){

   }


}

interface SportMan{
   void run();
   void competition();
}
interface Law{
   void rule();
}

接口与接口的多继承

package Demo1;

public class demo1{
   public static void main(String[] args){
   }
}
class PingpongMan implements SportMan{
 @Override
   public void rule(){

 }
   @Override
   public void abrosd(){

   }

   @Override
   public void run() {
      
   }

   @Override
   public void competition(){

   }

}

interface SportMan extends Law,Go{
   void run();
   void competition();
}
interface Law{
   void rule();
}
interface Go{
   void abrosd();
}

在这里插入图片描述
接口新增
在这里插入图片描述

package Demo1;

public class demo1{
   public static void main(String[] args){
      PingingMan zjk=new PingingMan();
      zjk.run();
     SportMan.inAddr();
   }
}
class PingingMan implements SportMan{

}

interface SportMan {
default void run(){
   go();
   System.out.println("跑的贼快");
}
static void inAddr(){
   System.out.println("在这里");
}
default void go(){
   System.out.println("开始");
}
}

实现多个接口注意事项
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
接口和抽象类相似

静态代码块

package Demo1;

import java.util.ArrayList;
import java.util.List;

public class demo1{
    public static List<String> cards=new ArrayList<>();
    static {
        System.out.println("静态代码块执行一次");
        cards.add("3");
        cards.add("4");
    }
   public static void main(String[] args){
     System.out.println("main方法执行一次");
     System.out.println(cards);
   }
}

逼格高
在这里插入图片描述
实例代码块
在这里插入图片描述
final关键字
在这里插入图片描述
在这里插入图片描述
单例模式
在这里插入图片描述

package Demo1;
public class demo1{
   public static void main(String[] args){
    SingleIntance01 s1=SingleIntance01.getInstance();
       SingleIntance01 s2=SingleIntance01.getInstance();
       System.out.println(s1==s2);
   }
}
class SingleIntance01{
    public static SingleIntance01 ins=new SingleIntance01();
    private SingleIntance01(){
    }
    public static SingleIntance01 getInstance(){
        return ins;
    }
}

在这里插入图片描述

package Demo1;
public class demo1{
   public static void main(String[] args){
    SingleIntance01 s1=SingleIntance01.getInstance();
       SingleIntance01 s2=SingleIntance01.getInstance();
       System.out.println(s1==s2);
   }
}
class SingleIntance01{
    public static SingleIntance01 ins=new SingleIntance01();
    private SingleIntance01(){
    }
    public static SingleIntance01 getInstance(){
        if(ins==null){
            ins=new SingleIntance01();
        }
        return ins;
        }
    }

枚举类
在这里插入图片描述
在这里插入图片描述
常量

package Demo1;
public class demo1 {
    public static final int up=0;
    public static final int down=1;
    public static final int left=2;
    public static final int right=3;
    public static void main(String[] args) {
       move(right);
    }
    public static void move(int oritation){
        switch (oritation){
            case up:
                System.out.println("上");
                break;
            case down:
                System.out.println("下");
                break;
            case left:
                System.out.println("左");
                break;
            case right:
                System.out.println("右");
                break;
        }
    }
}

枚举

package Demo1;

enum Oritation{
    up,down,left,right;
}
public class demo1 {
    public static void main(String[] args) {
       move(Oritation.right);
    }
    public static void move(Oritation oritation){
        switch (oritation){
            case up:
                System.out.println("上");
                break;
            case down:
                System.out.println("下");
                break;
            case left:
                System.out.println("左");
                break;
            case right:
                System.out.println("右");
                break;
        }
    }
}
第四天（多态、DATA、Object、正则）

API主要得记，直接用
多态
在这里插入图片描述
在这里插入图片描述
多态优势
在这里插入图片描述

package Demo1;


public class demo1 {
   public static void main(String[] args){
       Animal dlam=new Dog();
       dlam.run();
       Animal tatidi=new Dog();
       go(tatidi);
       Animal tom=new Cat();
       go(tom);
   }
   public static void go(Animal d){
       System.out.println("开始");
       d.run();
       System.out.println("结束");
   }
  class Dog extends Animal{
       @Override
       public void run(){
           System.out.println("快");
       }
       public void lookdoor(){
           System.out.println("看门");
       }
   }
 class Cat extends Animal{
       @Override
       public void run(){
           System.out.println("飞快");
       }
       public void catchMouse(){
            System.out.println("抓老鼠");
       }
   }
   class Animal{
       public void run(){
           System.out.println("动物跑得快");
       }
   }
}

报错

多态自动类型转换
在这里插入图片描述
强制类型转换
有报错

package Demo1;


public class demo1 {
   public static void main(String[] args){
       Animal dlam=new Dog();
       dlam.run();
      Dog d=(Dog) dlam;
      d.lookdoor();

      Animal al=new Cat();
      if (al instanceof  Cat){
          Cat c1=(Cat) al;
          c1.catchMouse();
      }else if(al instanceof Dog){
          Dog d1=(Dog) a1;
          d1.lookdoor();
      }

   }
   public static void go(Animal d){
       System.out.println("开始");
       d.run();
       System.out.println("结束");
   }
  class Dog extends Animal{
       @Override
       public void run(){
           System.out.println("快");
       }
       public void lookdoor(){
           System.out.println("看门");
       }
   }
 class Cat extends Animal{
       @Override
       public void run(){
           System.out.println("飞快");
       }
       public void catchMouse(){
            System.out.println("抓老鼠");
       }
   }
   class Animal{
       public void run(){
           System.out.println("动物跑得快");
       }
   }
}

案例

package Demo1;


public class demo1 {
   public static void main(String[] args){
      Computer c=new Computer();
      USB xiaomi=new Mouse("小米鼠标");
      c.install(xiaomi);
//      KeyBoard sfk=new KeyBoard("双飞燕键盘");
//       c.install(sfy);
   }
   static class Computer{
       public void install(USB usb){
           usb.connect();
           if(usb instanceof Mouse){
               Mouse m=(Mouse) usb;
               m.dbclick();
           }else if(usb instanceof Mouse){
               KeyBoard k=(KeyBoard) usb;
               k.keyDown();
           }
           usb.unconnect();
       }
   }
   static class Mouse implements USB{
       private String name;

       public Mouse(String name){
           this.name=name;
       }
       public void dbclick(){
           System.out.println(name+"老铁双击6666 ");

       }
       @Override
       public void connect(){
           System.out.println(name+"成功加入");
       }
       @Override
       public  void unconnect(){
           System.out.println(name+"成功拔出");
       }
      
   }
    static class KeyBoard implements USB{
        private String name;

        public KeyBoard(String name){
            this.name=name;
        }
        @Override
        public void connect(){
            System.out.println(name+"加入");
        }
        @Override
        public  void unconnect(){
            System.out.println(name+"拔出");
        }

        public void keyDown() {
            System.out.println(name+"小老弟你不行啊");
        }
    }
interface USB{
       void connect();
       void unconnect();
}
}

跳过内部类局部匿名类58-64

包
在这里插入图片描述
在这里插入图片描述
Object类 String()
在这里插入图片描述
在这里插入图片描述
equals
在这里插入图片描述
objects类
在这里插入图片描述

在这里插入图片描述
日期类
在这里插入图片描述

package Demo1;


import java.util.Date;

public class demo1 {
   public static void main(String[] args){
  Date d=new Date();
  System.out.println(d);

  long time=d.getTime();
  System.out.println(time);
}
}


package Demo1;


import java.util.Date;

public class demo1 {
   public static void main(String[] args){
  long startTime =new Date().getTime();
  for(int i=1;i<1000000;i++){
      System.out.println("输出："+i);
  }
  long endTime=new Date().getTime();
  System.out.println((endTime-startTime)/1000.0+"s");

       }
}

在这里插入图片描述
SimpleDateFormat
在这里插入图片描述

package Demo1;
import java.text.SimpleDateFormat;
import java.util.Date;

public class demo1 {
   public static void main(String[] args){
  Date d=new Date();
  System.out.println(d);

       SimpleDateFormat sdf=new SimpleDateFormat("yyy年MM月dd日||HH:mm:ss EEE a");
       String rs= sdf.format(d);
       System.out.println(rs);
       }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
面试例题

package Demo1;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class demo1 {
   public static void main(String[] args) throws ParseException {
   String date="2019-11-04 09:30:30";
   SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   Date newDate=sdf.parse(date);
   long time =newDate.getTime()+(24L *60*60+15*60*60+30*60+29)*1000;
   System.out.println(sdf.format(time));
       }
}

日历类
在这里插入图片描述
有点问题待解决……

package Demo1;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class demo1 {
   public static void main(String[] args) throws ParseException {
       Calendar rightNow=Calendar.getInstance();
       System.out.println(rightNow);
       int year =rightNow.get(Calendar.YEAR);
       //月得加一
       System.out.println(year);
       int days=rightNow.get(Calendar.DAY_OF_YEAR);
       System.out.println(days);
//       rightNow.set(Calendar.Year,2099);
//       System.out.println(rightNow.get(Calendar.YEAR));
       Date d=rightNow.getTime();
       System.out.println(d);

       long time= rightNow.getTimeInMillis();
       System.out.println(time);

       rightNow.add(Calendar.DAY_OF_YEAR,710);
       long time = rightNow.getTimeInMillis();
       SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
       System.out.println(sdf.format(time1));
       }
}

Math类
在这里插入图片描述

package Demo1;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class demo1 {
   public static void main(String[] args) throws ParseException {
     System.out.println(Math.abs(10));
     System.out.println(Math.abs(-10.3));
     System.out.println(Math.ceil(4.000001));//5.0
     System.out.println(Math.floor(4.9999999));//4.0
       System.out.println(Math.pow(2,3));
       System.out.println(Math.round(4.49999));//4
       System.out.println(Math.round(4.500001));//5
       }
}

系统类
在这里插入图片描述
在这里插入图片描述
大数据类
在这里插入图片描述
包装类
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
正则表达式

package Demo1;

public class demo1 {
   public static void main(String[] args) {
    System.out.println(checkQQ("2344124"));
       }
//正则表达式
//       public static boolean chechQQRegex(String qq){
//       return qq!=null&&qq.matches("\d{4,}");
//       }

       public static boolean checkQQ(String qq) {
         if (qq == null) {
           return false;
         } else {
           if (qq.length() >= 4) {
             boolean rs = true;
             for (int i=0;i<qq.length();i++){
               char ch=qq.charAt(i);
               if(ch<'0'||ch>'9'){
                 rs=false;
               }
             }
             return rs;
           } else {
             return  false;
           }
         }
       }
}

校验
在这里插入图片描述
在这里插入图片描述

package Demo1;

import java.util.Scanner;

public class demo1 {
   public static void main(String[] args) {
       checkEmalil();
       }

       public static void checkEmalil() {
           Scanner sc=new Scanner(System.in);
           System.out.println("请输入邮箱:");
           String email=sc.nextLine();
           if(email.matches("\w{1,}@\w{2,10}(\.\w{2,10}){1,2}")){
                System.out.println("邮箱合法");
           }else{
               System.out.println("不合法");
           }
       }
}

方法
在这里插入图片描述
爬取
在这里插入图片描述
范型
约束操作的数据类型
在这里插入图片描述
在这里插入图片描述
自定义泛型
在这里插入图片描述
方法
在这里插入图片描述
在这里插入图片描述
泛意接口
在这里插入图片描述
通配符
在这里插入图片描述
集合
在这里插入图片描述
在这里插入图片描述

第五天（遍历、Set、斗地主游戏案例）

遍历
在这里插入图片描述
在这里插入图片描述

package Demo1;

import java.util.ArrayList;
import java.util.Collection;

public class demo1 {
   public static void main(String[] args) {
       Collection<String>lists =new ArrayList<>();
       lists.add("赵敏");
       lists.add("小昭");
       lists.add("殷素素");
       lists.add("周芷若");
       System.out.println(lists);
       for(String ele :lists){
           System.out.println(ele);
       }
      //快捷键：lists.for 回车
       int [] ages=new int[]{17,18,38,21};
       for(int age:ages){
           System.out.println(age);
       }
   }
}

也可以
在这里插入图片描述
数据结构总类
在这里插入图片描述
在这里插入图片描述
红黑树
树-二叉树-二叉查找树-平衡二叉树-红黑数
在这里插入图片描述
ArrayList集合
在这里插入图片描述
在这里插入图片描述

package lianxi;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args){
        List<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java1");
        lists.add("java2");
        lists.add("java2");
        System.out.println(lists);
//某个索引位置插入元素
        lists.add(2,"MySQL");
        System.out.println(lists);
//根据索引删除元素，返回被删除元素
        System.out.println(lists.remove(2));
        System.out.println(lists);
//根据索引获取元素
        System.out.println(lists.get(2));
//修改索引位置处的元素
        lists.set(3,"Mybatis");
        System.out.println(lists);
       }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

队列
在这里插入图片描述
栈
在这里插入图片描述
set
在这里插入图片描述
斗地主案例

package lianxi;

public class Card {
    private String number;
    private String color;

    public Card(){

    }

    public Card(String number, String color) {
        this.number = number;
        this.color = color;
    }

    /**
     * 获取
     * @return number
     */
    public String getNumber() {
        return number;
    }

    /**
     * 设置
     * @param number
     */
    public void setNumber(String number) {
        this.number = number;
    }

    /**
     * 获取
     * @return color
     */
    public String getColor() {
        return color;
    }

    /**
     * 设置
     * @param color
     */
    public void setColor(String color) {
        this.color = color;
    }

    public String toString() {
        return number+color;
    }
}

做牌

package lianxi;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Demo2 {
   public static final List<Card> ALL_CARDS=new ArrayList<>();
   static {
           String[] numbers={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
           String[] colors={"黑桃","红心","梅花","方块"};
       for (String number : numbers) {
           for (String color : colors) {
               Card card=new Card(number,color);
               ALL_CARDS.add(card);
           }
       }
       Collection.addAll(ALL_CARDS,new Card("","小王"),new Card("","大王"));
       System.out.println("输出新牌："+ALL_CARDS);
   }
   public static void main(String[] args){

   }
}

洗牌

public static void main(String[] args){
       Collections.shuffle(ALL_CARDS);
       System.out.println("洗牌后："+ALL_CARDS);
   }

定义3玩家

list<Card> zhangsan1 = new ArrayList<>();
list<Card> zhangsan2 = new ArrayList<>();
list<Card> zhangsan3 = new ArrayList<>();

在这里插入图片描述
看牌
在这里插入图片描述
在这里插入图片描述

第六天

API与集合
链接

Stream
链接

IO输入输出
链接

File文件类
链接

反射
链接

第七天

自闭中……

m0_74823408
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java进阶学习路线图
热门推荐
逍遥飞鹤的专栏
08-14 2万+
职业发展道路基本有3条： 第一条路线（技术专精）： 初级Java开发---中级--高级---项目主管--Java项目经理---网站架构师----资深专家 第二条路线（技术转产品）：初级Java开发---中级--产品策划--产品经理---产品总监 第三条路线（技术转运营）：初级Java开发---中级--运营---运营经理---运营总监 这篇文字主要谈第一条路线：技术专精 　　　 第一
怎样才能从Java初级程序员成长为一名合格的架构师？
xiaoxijing的博客
11-11 1788
怎样学习才能从一名Java初级程序员成长为一名合格的架构师？或者说一名合格的架构师应该有怎样的技术知识体系？这不仅仅是一个刚刚踏入职场的初级程序员也是工作三五年之后开始迷茫的老程序员经常会问到的问题。下面，我来详细回答这些问题。希望这篇文章会是你看到过的最全面最权威的回答。 一、编程基础 不管是C还是C++，不管是Java还是PHP，想成为一名合格的程序员，基本的数据结构和算法基础还是要有的。下...
Java进阶篇
Java精灵
05-29 3960
Java面试中最常被问知识点（进阶篇）Java面试中最常被问的知识1、深复制和浅赋值的区别深复制：将指向内容复制到给当前对象新分配的缓冲区中的一种复制方式。浅复制：指当对象的字段值被复制时，字段引用的对象不会被复制。2、为什么Java中有些接口没有任何方法？3、什么是反射机制？反射的功能4、Java有几种创建对象的方法？5、简述final、finally、finalize的区别(1) finala、使用final声明属性时，表示属性不可再改变 ，且必须被初始化。b、使用final声明方法时，表示方法不可被重
Java技能提升指南
最新发布
大厂全栈码农
08-27 1万+
Java学习的过程是一个持续积累和实践的过程。通过夯实基础、深入理解进阶技能、在项目实战中锻炼、熟练使用工具与框架，以及保持对行业动态的关注，您将能够不断提升自己的Java技能，成为一名优秀的Java开发者。
java进阶
Green_hand_Tang的博客
04-24 961
一. 面向对象 面向对象和面向过程的思想对比 : 面向过程 ：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的。 优点：性能比面向对象高，因为类调用时需 要实例化，开销比较大，比较消耗资源；比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 缺点：没有面向对象易维护、易复用、易扩展 面向对象 ：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能。 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统
Java进阶
Xiaolv_0707的博客
12-29 835
抽象类由关键字abstract来修饰；抽象方法也有关键字abstract来修饰，且没有方法体连大括号都没有；抽象类可以含有抽象方法，也可以含有普通方法，也可以任何方法都不含；抽象类不能直接创建对象（建自己的对象），因为抽象类中含有了抽象方法后，使用对象的引用去调用是没有任何意义的；抽象类是可以通过多态的形式，建立子类对象的，这种方式叫做：向上造型；抽象类也是类，类与类之间就可以形成继承关系当一个普通类继承了抽象类后，就需要实现抽象类的全部抽象方法，即重写；
GitHub上14个屌炸天的Java进阶教程、面试真题项目，建议收藏！
m0_67393157的博客
08-01 1954
大家都知道Github是一个程序员福地，这里有各种厉害的开源框架、软件或者教程。这些东西对于我们学习和进步有着莫大的进步，所以我有了这个将Github上非常棒的Java开源项目整理下来的想法。转发+关注，然后添加VXtkzl6666即可获得我精心整理的《Java开源项目合集》资料。...
java架构师进阶之路
henhenha的博客
03-30 3859
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
【Java进阶营】JAVA面试攻略概述（一）一起来看看程序“猿”的年龄问题
04-26 756
找到合适的工作，总是要经过几轮的筛选，公司筛选面试者，面试者筛选公司。一手多个offer的大有人在，一个公司多个备手人员储备，两者既要紧密合作，还要相互甄别筛选，为了获得更好的公司offer，每个求职者都需要精心准备，面试不同于考试，我们所做的就是通过准备增加获得offer的概率。 针对java面试的求职者，每家公司都想招到技术大牛，人又靠谱的面试者，鉴于这样的需求前提，面试人员就需要从两方面进行准备，首先要准备技术储备，技术知识的储备短期内是可以速成的，面试的技术知识就相当于一次小的集中考试，是否还记得
java进阶之路 。。
07-24
java进阶之路 详细说明java程序员的成长之路
JAVA进阶学习
xw_Summer的博客
11-04 4082
进阶学习过程的几个方面 第一阶段的学习是java基础的学习和javaEE的学习。 第二阶段就是java学习的进阶啦。主要是面试书籍，下面是书籍推荐： 多线程、并发 实战java高并发程序设计和java并发编程的艺术： ——“java高并发程序设计”，这本书主要是为了看第二本书做铺垫，直接看第二本书可能会很吃力。实战java高并发程序设计主要看：前4章、5.1、5.2、5.3、5.10、5.11和第...
Java语法进阶
一杯咖啡
02-07 507
一、Object类、常用API 二、Collection、泛型 三、List、Set、数据结构、Collections 四、Map与斗地主案例 五、异常、线程 目标： 1、说出进程的概念 2、说出线程的概念 3、能够理解并发与并行的区别 4、能够开启新线程 4.1 并发与并行 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 4.2 线程与进...
高级Java程序员的技术进阶之路
weixin_30326741的博客
07-07 499
  据不完全统计，截至目前(2017.07)为止，中国Java程序员的数量已经超过了100万。而且，随着IT培训业的持续发展和大量的应届毕业生进入社会，Java程序员面临的竞争压力越来越大。那么，作为一名Java初级程序员，怎样努力才能快速成长为一名高级的程序员或者架构师，或者说一名优秀的高级工程师或架构师应该有怎样的技术知识体系，这不仅一个刚刚踏入职场的初级程序员，也是工作三五年之后开始迷茫的老...
Java后端工程师学习大纲
weixin_33901843的博客
07-08 317
2019独角兽企业重金招聘Python工程师标准>>> ...
编程思想革命：Java进阶指南
"编程思想系列丛"是一本专注于Java编程领域的深化读物，它将计算机革命的起源与编程语言的发展紧密相连，强调了早期机器对现代编程语言设计的影响。书中可能探讨了编程语言的发展历程，从最初的机器结构出发，如何...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值