首页 文章 精选 留言 我的

精选列表

搜索[java]，共10000篇文章
优秀的个人博客,低调大师

Java 面向对象 之 final 关键字

http://www.verejava.com/?id=16992827836151 /** 知识点: final 关键字 1. 什么是final : final 就是最终的意思 2. final 关键字修饰的变量是常量 不能修改 3. final 关键字修饰的方法，子类不能复写 4. final 关键字修饰的类，不能被继承 */ public class FinalKeyword { public static void main(String[] args) { final double PI = 3.14; System.out.println(PI); //实例化父亲 Father f = new Father(); f.work(); //实例化儿子 Son s = new Son(); s.study(); } } //父亲 class Father { public final void work() { System.out.println("干农活"); } } //儿子 class Son extends Father { public void study() { System.out.println("好好学习，天天向上"); } } //女儿 final class Daughter extends Father { } //孙子 class GranSon extends Son { } http://www.verejava.com/?id=16992827836151
2018-08-22
优秀的个人博客,低调大师

Java 面向对象 之 super 关键字

http://www.verejava.com/?id=17159596599630 /** this: 代表当前类的引用 1. 当局部变量和成员变量同名时, 成员变量要加 this 限定 2. 实例化时 可以用 this 调用当前类的构造方法, 必须写在第一行 3. 可以用 this 调用当前类的 普通方法 super : 代表当前父类的引用 1. 实例化子类时， 可以用 super 调用父类的 非私有方法 2. 实例化子类时. 可以用 super 调用父类的 构造方法 , 必须写在第一行 3. 在子类的方法中 ， 可以用 supe 调用父类的 非私有方法. */ public class Test1 { public static void main(String[] args) { // 实例化 农夫 Father father = new Father(); father.setName("农夫"); father.setAge(90); System.out.println(father.getAge() + " 岁 " + father.getName() + " 有 " + father.getWealth()); Father father = new Father("农夫", 90); System.out.println(father.getAge() + " 岁 " + father.getName() + " 有 " + father.getWealth()); Son son = new Son("农夫", 90); System.out.println("儿子知道父亲的 ： " + son.getAge() + " 岁 " + son.getName() + " 有 " + son.getWealth()); son.work(); } } //父类 class Father { private String name; private int age; private String wealth; public Father() { wealth = "100两黄金"; } public Father(String name, int age) { this(); this.name = name; //this.age=age; this.setAge(90); } public void work() { System.out.println("耕地"); } public String getWealth() { return wealth; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public void setName(String name) { this.name = name; } public String getName() { return name; } } //子类 class Son extends Father { public Son(String name, int age) { super(name, age); //super.setName(name); //super.setAge(age); } public void work() { super.work(); System.out.println("儿子 寻找黄金宝藏"); System.out.println("只有通过自己的勤奋劳动, 才能得到果实 是最大的宝藏"); } } http://www.verejava.com/?id=17159596599630
2018-08-22
优秀的个人博客,低调大师

Java 面向对象 之 关键字instanceof

http://www.verejava.com/?id=16992811364048 /** 知识点: 关键字 instanceof 题目：输出参加Oracle大会的人分类信息 思路: 1. 抽象出类 : 会议厅(Hall), 人种(Person){程序员(Programer),管理者(Manager)} 2. 找出类关系: 2.1 {程序员(Programer),管理者(Manager)} 是 人种(Person) 分类 2.2 人种(Person)->会议厅(Hall) 3. 找出属性: 3.1 会议厅(Hall)(会议名称,容纳人数) 3.2 人种(Person)(姓名) 4. 找出方法: 4.1 要参加会议 会议厅(Hall) 登记参加会议的每个人信息 register(Person p) 4.2 输出参加大会的人信息 output() */ public class TestInstanceof { public static void main(String[] args) { //Oracle说我要在Moscore center 举办一年一度的大会, 需要一个 //容纳1000人的会厅 //开一个能容量1000人的会厅 Hall h = new Hall(1000); //开始登记注册 h.register(new Programer("Joseph")); h.register(new Programer("james")); h.register(new Manager("Page")); h.register(new Manager("Joe")); //打印输出 h.output(); } } class Hall { private String name;//会议名称 private Person[] persons;//登记册 public Hall(int maxSize) { persons = new Person[maxSize]; } //登记每个参加会议的人信息 //思路: // 1. 循环检测如果没有超出容量，将该人添加到 登记册 // 如果超出容量,提示已经没有注册名额,注册完毕 public void register(Person newPerson) { int flag = 0;//检测是否注册完毕 for (int i = 0; i < persons.length; i++) { if (persons[i] == null) { persons[i] = newPerson; break; } flag++; } if (flag == persons.length) { System.out.println("已经没有注册名额,注册完毕"); } } //输出参加大会的人分类信息 // 思路: // 1. 循环打印出每个已经参加登记人的信息 // 2. 但是在循环打印的时候要判断 到底打印的是 程序员 还是 经理 public void output() { for (int i = 0; i < persons.length; i++) { //打印已经登记的人信息 if (persons[i] != null) { if (persons[i] instanceof Programer) { System.out.println(persons[i].getName() + " 属于程序员"); } if (persons[i] instanceof Manager) { System.out.println(persons[i].getName() + " 属于经理以上级别"); } } } } } abstract class Person { protected String name;//姓名 public Person(String name) { this.name = name; } public String getName() { return this.name; } } class Programer extends Person { public Programer(String name) { super(name); } } class Manager extends Person { public Manager(String name) { super(name); } } http://www.verejava.com/?id=16992811364048
2018-08-17
优秀的个人博客,低调大师

Java 面向对象 之 抽象类 abstract

http://www.verejava.com/?id=16992804621647 /** 知识点： 抽象类 abstract 题目: 爸爸叫我买一斤水果和一条鱼 思路： 1. 抽象出类：爸爸(Father), 儿子(Son), 水果(Fruit),鱼(Fish) 2. 找出类关系: 儿子继承爸爸 水果买回来属于->Father->Son 3. 找出方法: 买(buy) 是爸爸叫儿子买水果,爸爸知识发出了要求声明并没用实现 而真正去实现这个是儿子 */ /** 注意: 1. 加了关键字 abstract 的抽象方法不能有方法体实现,只能有方法的声明 2. 当一个类中存在以 abstract 声明的抽象方法时, 该类必须加上abstract 关键 字表明该类是抽象类 3. 子类如果继承一个抽象类, 子类必须实现父类所有的抽象方法 4. 抽象类中也可以声明实现方法，也就是抽象类中可以定义抽象方法，也可以定义 带方法体的实现方法，而子类不需要复写抽象父类的具体已经实现的方法 5. 抽象类不能直接实例化，必须有其实现的子类间接来实例化 */ public class TestAbstract { public static void main(String[] args) { //实例化父亲 //Father f=new Father(); //实例化儿子 Son s = new Son("李明"); //地摊上有各种水果和鱼 Fruit apple = new Fruit("苹果"); Fruit grape = new Fruit("葡萄"); Fish caoyu = new Fish("草鱼"); Fish lianyu = new Fish("鲢鱼"); //买水果和鱼 s.buy(apple); s.buy(lianyu); //回家以后高兴的告诉爸爸 System.out.println("爸爸,爸爸 我买了一斤:" + s.getFruit().getName() + " 和一条 : " + s.getFish().getName()); } } abstract class Father { protected Fruit fruit; protected Fish fish; public Fruit getFruit() { return this.fruit; } public Fish getFish() { return this.fish; } //要求声明要买水果 public abstract void buy(Fruit fruit); //要求声明要买条鱼 public abstract void buy(Fish fish); } class Son extends Father { private String name; public Son(String name) { super(); this.name = name; } //儿子实现父亲买水果的要求 public void buy(Fruit fruit) { this.fruit = fruit; } //儿子实现父亲买条鱼的要求 public void buy(Fish fish) { this.fish = fish; } public String getName() { return this.name; } } class Fruit { private String name; public Fruit(String name) { this.name = name; } public String getName() { return this.name; } } class Fish { private String name; public Fish(String name) { this.name = name; } public String getName() { return this.name; } } http://www.verejava.com/?id=16992804621647
2018-08-16
优秀的个人博客,低调大师

（十五）Java并发性和多线程-死锁

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。 例如，如果线程1锁住了A，然后尝试对B进行加锁，同时线程2已经锁住了B，接着尝试对A进行加锁，这时死锁就发生了。线程1永远得不到B，线程2也永远得不到A，并且它们永远也不会知道发生了这样的事情。为了得到彼此的对象（A和B），它们将永远阻塞下去。这种情况就是一个死锁。 该情况如下： Thread 1 locks A, waits for B Thread 2 locks B, waits for A 一个简单的死锁类 当DeadLock类的对象flag==1时（td1），先锁定o1,睡眠500毫秒 而td1在睡眠的时候另一个flag==0的对象（td2）线程启动，先锁定o2,睡眠500毫秒 td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定； td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定； td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 import lombok.extern.slf4j.Slf4j; @Slf4j public class DeadLock implements Runnable { public int flag = 1; //静态对象是类的所有对象共享的 private static Object o1 = new Object(), o2 = new Object(); @Override public void run() { log.info("flag:{}", flag); if (flag == 1) { synchronized (o1) { try { Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); } synchronized (o2) { log.info("1"); } } } if (flag == 0) { synchronized (o2) { try { Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); } synchronized (o1) { log.info("0"); } } } } public static void main(String[] args) { DeadLock td1 = new DeadLock(); DeadLock td2 = new DeadLock(); td1.flag = 1; td2.flag = 0; //td1,td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的。 //td2的run()可能在td1的run()之前运行 new Thread(td1).start(); new Thread(td2).start(); } }
2018-08-16
优秀的个人博客,低调大师

（二）Java并发学习笔记--安全发布对象

逸出的方式 上边关于逸出的概念讲述的很是模糊，下面列举几个逸出的示例。 通过静态变量引用逸出 public static Set<Secret> knownSecrets; public void initialize() { knowsSecrets = new HashSet<Secret>(); } 上边代码示例中，调用initialize方法，发布了knowSecrets对象。当你向knowSecrets中添加一个Secret时，会同时将Secret对象发布出去，原因是可以通过遍历knowSecrets获取到Secret对象的引用，然后进行修改。 通过非静态（私有）方法 class UnsafeStates { private String[] states = new String[]{"AK", "AL"}; public String[] getStates() { return states; } } 以这种方式发布的states会出问题，任何一个调用者都能修改它的内容。数组states已经逸出了它所属的范围，这个本应该私有的数据，事实上已经变成共有的了。 this逸出 public class ThisEscape { public ThisEscape(EventSource source) { source.registerListener(new EventListener() { public void onEvent(Event e) { doSomething(e); } }); } } 在上边代码中，当我们实例化ThisEscape对象时，会调用source的registerListener方法时，便启动了一个线程，而且这个线程持有了ThisEscape对象（调用了对象的doSomething方法），但此时ThisEscape对象却没有实例化完成（还没有返回一个引用），所以我们说，此时造成了一个this引用逸出，即还没有完成的实例化ThisEscape对象的动作，却已经暴露了对象的引用，使其他线程可以访问还没有构造好的对象，可能会造成意料不到的问题。 通过上述示例，个人理解，对逸出的概念应该定义为： 一个对象，超出了它原本的作用域，而可以被其它对象进行修改，而这种修改及修改的结果是无法预测的。换句话说：一个对象发布后，它的状态应该是稳定的，修改是可被检测到的。如果在其它线程修改（或做其它操作）一个对象后导致对象的状态未知，就可以说这个对象逸出了。 总之，一个对象逸出后，不论其它线程或对象是否使用这个逸出的对象都不重要，重要的是，被误用及被误用后的未知结果的风险总是存在的。 PS 书中给出了避免this逸出的方法： public class SafeListener { private final EventListener listener; private SafeListener() { listener = new EventListener() { public void onEvent(Event e) { doSomething(e); } }; } public static SafeListener newInstance(EventSource source) { SafeListener safe = new SafeListener(); source.registerListener(safe.listener); return safe; } } 在这个构造中，我们看到的最大的一个区别就是：当构造好了SafeListener对象之后，我们才启动了监听线程，也就确保了SafeListener对象是构造完成之后在使用的SafeListener对象。 对于这样的技术，书里面也有这样的注释： 具体来说，只有当构造函数返回时，this引用才应该从线程中逸出。构造函数可以将this引用保存到某个地方，只要其他线程不会在构造函数完成之前使用它。 安全发布对象 在静态初始化函数中初始化一个对象引用 将对象的应用保存到volatile类型的域或者AtomicReferance对象中 将对象的引用保存到某个正确构造对象的final类型域中 将对象的引用保存到一个由锁保护的域中。 /** * 懒汉模式（线程不安全） * 单例实例在第一次使用时进行创建 */ @NotThreadSafe public class SingletonExample1 { // 私有构造函数 private SingletonExample1() { } // 单例对象 private static SingletonExample1 instance = null; // 静态的工厂方法 public static SingletonExample1 getInstance() { // 这里同时有两个线程进入就可能同时初始化两个对象 if (instance == null) { instance = new SingletonExample1(); } return instance; } } 懒汉模式本身是线程不安全的，如果想要实现线程安全可以通过synchronized关键字实现： /** * 懒汉模式 * 单例实例在第一次使用时进行创建 */ @ThreadSafe @NotRecommend public class SingletonExample3 { // 私有构造函数 private SingletonExample3() { } // 单例对象 private static SingletonExample3 instance = null; // 静态的工厂方法 public static synchronized SingletonExample3 getInstance() { if (instance == null) { instance = new SingletonExample3(); } return instance; } } 但此中方式不推荐使用，应该它通过同一时间内只允许一个线程来访问的方式实现线程安全，但是却带来了性能上面的开销。 我们可以通过以下方式来实现线程安全： 懒汉模式 -》 volatile + 双重同步锁单例模式 /** * 懒汉模式 -》 双重同步锁单例模式 * 单例实例在第一次使用时进行创建 */ @ThreadSafe public class SingletonExample4 { // 私有构造函数 private SingletonExample4() { } // 1、memory = allocate() 分配对象的内存空间 // 2、ctorInstance() 初始化对象 // 3、instance = memory 设置instance指向刚分配的内存 // JVM和cpu优化，发生了指令重排（多线程 ） // 1、memory = allocate() 分配对象的内存空间 // 3、instance = memory 设置instance指向刚分配的内存 // 2、ctorInstance() 初始化对象 // 单例对象 volatile + 双重检测机制 -> 禁止指令重排 private volatile static SingletonExample4 instance = null; public static SingletonExample4 getInstance() { if (instance == null) { // 双重检测机制 // B synchronized (SingletonExample4.class) { // 同步锁 if (instance == null) { instance = new SingletonExample4(); // A - 3 } } } return instance; } } /** * 饿汉模式 * 单例实例在类装载时进行创建 */ @ThreadSafe public class SingletonExample2 { // 私有构造函数 private SingletonExample2() { } // 单例对象 private static SingletonExample2 instance = new SingletonExample2(); // 静态的工厂方法 public static SingletonExample2 getInstance() { return instance; } } 饿汉模式不会有线程问题，但是在类加载时实例化对象。使用时要考虑两点： 私有构造函数在使用时没有过多的逻辑处理（销毁性能，慢） 这个对象一定会被使用（浪费资源） 在静态代码块中实例化一个对象： /** * 饿汉模式 * 单例实例在类装载时进行创建 */ @ThreadSafe public class SingletonExample6 { // 私有构造函数 private SingletonExample6() { } // 单例对象 private static SingletonExample6 instance = null; static { instance = new SingletonExample6(); } // 静态的工厂方法 public static SingletonExample6 getInstance() { return instance; } public static void main(String[] args) { System.out.println(getInstance().hashCode()); System.out.println(getInstance().hashCode()); } } 枚举模式： /** * 枚举模式：最安全 */ @ThreadSafe @Recommend public class SingletonExample7 { // 私有构造函数 private SingletonExample7() { } public static SingletonExample7 getInstance() { return Singleton.INSTANCE.getInstance(); } private enum Singleton { INSTANCE; private SingletonExample7 singleton; // JVM保证这个方法绝对只调用一次 Singleton() { singleton = new SingletonExample7(); } public SingletonExample7 getInstance() { return singleton; } } }
2018-08-14
优秀的个人博客,低调大师

Java 面向对象 之 static 关键字

http://www.verejava.com/?id=16992774752140 /** 知识点: static 关键字 1. static 的使用 2. static 变量的内存分配 3. static 的使用限制 4. 主方法 main 的剖析 */ public class TestStatic { public static void main(String[] args) { //实例化一个用户 User user1 = new User("xiongmao"); User.count++; System.out.println("实例化用户总数 : " + User.count); //实例化第二个用户 User user2 = new User("tanglang"); User.count++; System.out.println("实例化用户总数 ：" + User.count); } } class User { private String username;//用户名 public static int count;//计数器 public User(String username) { this.username = username; } } /** 总结 普通变量和static静态变量的区别 1. 普通变量是运行期动态赋的值 static 变量是在 编译期 就赋给了初始值 2. 普通变量必须通过实例对象引用访问 static 变量可以直接通过类名访问 3. 普通变量存在 堆和栈中 static 变量存在全局代码区中 是共享的 */ http://www.verejava.com/?id=16992774752140
2018-08-09
优秀的个人博客,低调大师

探讨Java中的父子类转化问题

有两个问题： （1）子类对象可以转化为父类对象吗？ （2）父类对象可以转化为子类对象吗？ ------------------------------------------------------------------------------------------------------------------------------------ 第（1）个问题应该都不陌生，也没什么好探讨的，肯定可以，因为在多态中经常用到。 如：class Father{} calss Son extends publc Father{} Father f = new Son(); //父类引用指向子类对象 其中，new Son()表示在在堆中分配了一段空间来存放类Son中的数据， 并返回一个Son的对象，并赋值给Father的引用f，即f指向子类的对象， 此时，子类的对象并没有定义一个名字。 定价于： Son s = new Son(); Father f = s; ------------------------------------------------------------------------------------------------------------------------------------ 第（2）个问题：一般情况下，父类对象是不可以强制转化为子类对象的， 如： class Father{} calss Son : publc Father{} Son s = new Father(); //error 因为，子类除了从父类继承一些东西外，它还增加了一些自己的东西，也就是说， 子类对象一般都比父类对象包含更多的东西。这样的话，子类如果访问子类新增的内容， 而这些内容父类并没有，所以就会报错。 但是，如果前提是：此父类对象已经指向了此子类对象，就可以转换。 如: Father f = new Son(); //父类引用指向子类对象 Son s2 = (Son)f; //可以 因为，子类强制转换为父类对象时，并没有实际丢失它原有内存空间（比父类多的那些部分） 只是暂时不可访问，所以能再转回来。 一般在前面加一条判断语句if(fatherinstanceofSon)；防止报ClassCastExcept异常。 如： Father f = new Son(); //父类引用指向子类对象 if(fatherinstanceofSon){Son s2 = (Son)f;} 结论：（1）子类对象可以转化为父类对象 （2）一般不可以，但是如果此父类已经指向了此子类对象，可以
2018-08-06

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-01-03 大小: 1.42GB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
热门标签
OpenAi Nacos3 Kubernetes Docker Service Mesh SpringBoot4 Rocky Gemini3 HarmonyOS6 DeepSeek Redis SpringCloud Jdk25

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册