JavaSE进阶

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量72 收藏
点赞数
文章标签： java 抽象类 object interface 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44644871/article/details/111051682
版权

final修饰的类无法修饰

final关键字

final是java中的一个关键字
final用于变量声明，被声明的变量的值将无法改变
子类能继承超类，能对超类的功能进行拓展，如果不希望子类对超类进行拓展 可以给超类加final关键字，这样子类就无法继承超类了

final修饰的类无法被继承

 final class A{
}
class B extends A{
}
//java: 无法从最终A进行继承

final也可以修饰变量；

  public static void main(String[] args) {
       final double pi=3.14;
       pi=2.5;
        System.out.println(pi);
    }
    //java: 无法为最终变量pi分配值

如果被final修饰的是一个引用也不能二次赋值
但可以利用类中的方法去改变类中的变量

class A{
    int a;
    public A() { }
    public int getA() {return a;}

    public A(int a) { this.a = a; }

    public void fu(int a) { this.a=a; }
}
public class jihuo{
    public static void main(String[] args) {
        final A a=new A(10);
        a.fu(20);
        a=new A(5);//报错
    }
}
//java: 无法为最终变量a分配值

超类中被final修饰的方法无法被子类重写和覆盖

class A{
    public final void printl()
    {
        System.out.println("jykglyu");
    }
}
class B extends A{
    public void printl()
    {
    	System.out.println("rdyt");
    }
}
//java: B中的printl()无法覆盖A中的printl()
  //被覆盖的方法为final

补充：超类调用子类的方法 需要向下转型

class A{
    public  void printl()
    {
        System.out.println("jykglyu");
    }
}
class B extends A{
    public void domel()
    {
        System.out.println("hello world");
    }
}
public class jihuo{
    public static void main(String[] args) {
        A a=new B();
        //a.domel();
        //报错  
        if(a instanceof B)
        {
            B b1=(B)a;
            ((B) a).domel();
            b1.domel();
        }
    }
}

补充：当类中的变量没有初始化时，类中的构造函数会将变量默认设置为0；但加了final的变量不能被构造函数初始化
错误

class A{
    int country;
    public int getCountry() { return country; }
}
public class jihuo{
    public static void main(String[] args) {
         A a=new A();
        System.out.println(a.getCountry());
    }
}

错误

class A{
    final int country;
    public int getCountry() { return country; }
}
public class jihuo{
    public static void main(String[] args) {
         A a=new A();
        System.out.println(a.getCountry());
    }
}

所以程序员必须手动初始化final定义的变量

抽象类

在普通类的基础上扩充了一些抽象方法（0~n）的类（抽象类是普通类的超集），使用abstract关键字定义。
抽象类不能直接产生实例化对象，因为抽象类是“半成品”，无法直接使用。不能直接new。
抽象类abstract不能与final一起使用。
抽象类的子类可以是抽象类也可以是普通类。
抽象方法：使用abstract 关键字定义并且没有方法体的方法。抽象方法必须在抽象类中，但抽象类中可以没有抽象方法。

抽象类中的抽象方法不能有主体

abstract class A{
    public  abstract void move(){}
}//报错
//java: 抽象方法不能有主体

一个非抽象类继承抽象类必须覆盖抽象类中的抽象方法,或者将子类改为抽象类

abstract class A{
    public  abstract void move();
}
 class B extends A{
 //public void move(){}
}
//报错
//java: B不是抽象的, 并且未覆盖A中的抽象方法move()

在主函数中可以通过父类型引用指向子类型对象
A a=new B();
a.move();
如果B 也是抽象类 那么就可以不用重写A中的方法
一道面试题：java中没有方法体的方法都是抽象方法（T/F）
答案：F
解释：例如Object类中就有很多方法没有方法体，但他们多不是抽象方法，例如：public native inthashCode()；这个方法是调用C++写的动态链接库程序。前面没有abstract。有一个native，表示调用JVM本地程序。

接口

接口基础语法
接口也是一种“引用数据类型”。编译之后也是一个字节码文件
接口是完全抽象的。是一种特殊的抽象类。
接口支持多继承，一个抽象类支持继承多个父类
接口中包含两部分，一部分是常量，一部分是抽象方法
接口中的方法不能有方法体

public class text1 {
    public static void main(String[] args) {
        System.out.println(A.PI);//调用接口中的变量，接口中的变量不能改变
    }
}
interface C extends A,B{//一个接口支持多继承
	public static final double PI=3.1415926;//接口中常量可以省略public static final
    public abstract int moth();//方法名可以省略public abstract
}

package Interface;

public class text2 {
    public static void main(String[] args) {
        FoudMenu cooker=new AmerCook();
        Custermor custermor=new Custermor(cooker);
        custermor.redor();
        FoudMenu cooker1=new ChinaCook();
        Custermor custermor1=new Custermor(cooker1);
        custermor1.redor();
    }
}
class ChinaCook implements FoudMenu {
    public void xhscjd(){
        System.out.println("我是中餐厨师我会西红柿炒鸡蛋");
    }
    public void yxrs()
    {
        System.out.println("我是中餐厨师我会做鱼香肉丝");
    }
}
class AmerCook implements FoudMenu{
    public void xhscjd(){
        System.out.println("我是西餐厨师我不会西红柿炒鸡蛋");
    }
    public void yxrs()
    {
        System.out.println("我是西餐厨师我不会做鱼香肉丝");
    }
}
class Custermor{
    private FoudMenu foodmenu;
    public Custermor(){ }
    public Custermor(FoudMenu foodmenu)
    {
        this.foodmenu=foodmenu;
    }
    public void setFoodmenu(FoudMenu foodmenu){
        this.foodmenu=foodmenu;
    }
    public FoudMenu getFoodmenu(){
        return this.foodmenu;
    }
    public void redor(){
        foodmenu.xhscjd();
        foodmenu.yxrs();
    }
}
interface FoudMenu{
    void xhscjd();
    void yxrs();
}

抽象类与接口的区别

类与类之间叫继承，类与接口之间叫做实现
继承使用extends，实现使用implements关键字
接口是一个抽象概念，
可插拔性

package Interface;
public class text2 {
    public static void main(String[] args) {
        Flyable f=new Cat();
        f.fly();
        Flyable f1=new Snake();
        f1.fly();
        Flyable f2=new Pig();
        f2.fly();
    }
}
interface Flyable{
    void fly();
}
class Animal{}
class Cat extends Animal implements Flyable{
    public void fly()
    {
        System.out.println("我是一只神奇的星猫");
    }
}
class Snake extends Animal implements Flyable{
    public void fly(){
        System.out.println("我是一条蛇，我不会飞");
    }
}
class Pig extends Animal implements Flyable{
    public void fly()
    {
        System.out.println("我是一只猪，我想飞");
    }
}
/*我是一只神奇的星猫
我是一条蛇，我不会飞 
我是一只猪，我想飞*/

在这里插入图片描述
补充：
1.一个类可以实现多个接口，与之相反一个类只能继承一个父类
2.接口结合多态使用才能降低程序的耦合度
3.（is a）继承，(has a)关联，(like a)实现在这里插入图片描述
抽象类是半抽象的。
接口是完全抽象。

抽象类中有构造方法。
接口中没有构造方法。

类与类之间只能单继承。
接口与接口之间支持多继承。

接口中只存在常量与

package和import

package出现在java源文件的第一行
一个Java源代码程序就是一个编译单元，每个编译单元都必须有一个后缀名.java，而在编译单元内有且仅有一个public类，否则编译器就不会接受。该public类的名称必须与文件的名称相同（包括大小写，但不包括后缀名.java）
假设文件名称TelephonyManager，就有一个公共类TelephonyManager

访问控制权限

在这里插入图片描述
访问控制权限可以修饰什么
属性（四个都可以）
方法（四个都可以）
类（只能由public和默认修饰，其他的不行 ）
接口（只能由public和默认修饰，其他的不行）

Object类

JDK类库的根类是Object
当使用equals（）时默认比较的是内存地址；
在java中字符串和引用数据类型的比较一般采用equals（）

System.out.println("b" == "b");	//true
System.out.println("a".equals("a")); //true
System.out.println("a".equals(new String("a"))); //true
System.out.println("a" == new String("a"));	//false
System.out.println(new String("a") == new String("a")); //false
System.out.println(new String("a").equals(new String("a"))); //true

数据类型的比较采用“==”
以后所有类的equals（）方法需要重写，因为Object中的equals（）方法比较的是两个对象的内存地址，我们一般会比较内容，所以需要重写，如下所示

package Objecttext;
import java.util.TreeMap;
public class text {
    public static void main(String[] args) {
        Mytext t = new Mytext();
        Mytext t1 = new Mytext();
        String s = t.toString();
        System.out.println(s);
        System.out.println(t1 == t);
        System.out.println(t1.equals(t));
    }
}
class Mytext {
    int id = 1000;
    int age = 55;
    String name = "hvhvhjvjuyyswsyiuliuts";
    public Mytext() {}
    public Mytext(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    @Override
    public String toString() {
        return "Mytext{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    public boolean equals(Object obj) {
        int id = this.id;
        int age = this.age;
        String name = this.name;
        if (obj instanceof Mytext) {
            Mytext t = (Mytext) obj;
            int id1 = t.id;
            int age1 = t.age;
            String name1 = t.name;
            if (id == id1 && age == age1 && name == name1) {
                return true;
            }
        } return false;
    }
}
//输出
//Mytext{id=1000, age=55, name='hvhvhjvjuyyswsyiuliuts'}
//false
//true

基本数据类型的比较使用“==”；
对象与对象的比较使用equals（）；

object中equals重写并对两个相同的对象进行比较

package Objecttext;

public class text01 {
    public static void main(String[] args){
        User u1=new User("zhangsan",new Address("bjs","dxq","356856"));
        User u2=new User("zhangsan",new Address("bjs","dxq","356856"));
        User u3=new User("LiShi",new Address("bjs","dxq","356856"));
        System.out.println(u1.equals(u3));
        System.out.println(u1.equals(u2));
    }
}
class User
{
    String name;
    Address addr;
    public User() {}
    public User(String name,  Address addr) {
        this.name = name;

        this.addr = addr;
    }
    public boolean equals(Object obj)
    {
        if (obj==null||!(obj instanceof User))
            return false;
        if (this==obj)
            return true;
        User u=(User)obj;
        if (this.name.equals(u.name)&&this.addr.equals(u.addr))
        {
            return true;
        }
        return false;

    }
}
class Address{
    String city;
    String street;
    String zipcode;
    public Address(){}
    public Address(String city, String street, String zipcode) {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }
    public boolean equals(Object obj )
    {
        if (obj==null||!(obj instanceof Address))
            return false;
        if (this==obj)
            return true;
        Address a=(Address)obj;
        if (this.city.equals(a.city)&&this.street.equals(a.street)&&this.zipcode.equals(a.zipcode))
            return true;
        return false;

    }
}
//结果返回true

关于object类中的finalize（）方法。
在Object类的原码中：

protected void finalize() throws  Throwable{}

finalize（）方法没有方法体， 里面没有代码，而且这个方法是用protected修饰的。
这个方法不需要程序员调用，jvm垃圾回收器负责调用这个方法，当一个java对象即将被垃圾回收器回收时垃圾回收器负责调用finalize（）方法。
它不像equals（）和toString（）需要你写代码调用，finalize（）只需要你重写，重写完以后自动会有程序来调用，GC调用finalize（）方法

静态代码块的作用是什么？
static{}
静态代码块在类加载的时刻执行，并且只执行一次。是一个加载时机，final则是一个垃圾回收时机。

java中的垃圾回收器不轻易启动，垃圾太少或时间没到都不启动

package Objecttext;

public class text02 {
    public static void main(String[] args) {
        //创建对象
       for (int i=0;i<1000000;i++)
       {
           nume f=new nume();
           f=null;
           System.gc();//垃圾回收器建议启动方法
       }
    }
}
class nume{
    //重写finalize（）方法
    //nume类型的对象被垃圾回收器回收的时候垃圾回收器负责调用f.finzlize();
    protected void finalize() throws Throwable{
        System.out.println("即将被回收");
    }
}
//即将被回收
//即将被回收.........

hashCode方法：
在Object中的hashCode方法是怎么样的？
public native inthashCode（）；
这个方法不是抽象方法，带有native，是调用底层C++程序。
hashCode返回的是哈希码：
实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值。
所以hashCode（）方法的执行结果可以等同于一个java对象的内存地址。

public class text03 {
    public static void main(String[] args) {
        Object o=new Object();
        int hc=o.hashCode();
        nume n=new nume();
        int hs=n.hashCode();
        System.out.println(hc);
        System.out.println(hs);
    }
}
class nump{
}

匿名内部类

普通接口实现加法计算

public class Main {
    public static void main(String[] args) {
	// write your code here
        mymath m=new mymath();
        comp c=new Compler();
        m.mysun(c,1,3);
    }
}
interface comp{
    int sum(int x,int y);
}
class Compler implements comp{
    public int sum(int x,int y){
        return x+y;
    }
}
class mymath
{
    public void mysun(comp c,int x,int y)
    {
        int ret=c.sum(x,y);
        System.out.println(x+" + "+y+"="+ret);
    }
}

利用匿名内部类实现加法计算

public class Main {
    public static void main(String[] args) {
        mymath m=new mymath();

        m.mysun(new comp(){
          public   int sum(int x,int y){
              return x+y;
          }
        },1,3);
    }
}
interface comp{
    int sum(int x,int y);
}
class mymath
{
    public void mysun(comp c,int x,int y)
    {
        int ret=c.sum(x,y);
        System.out.println(x+" + "+y+"="+ret);
    }
}

hashmap

双列集合

自定义的枚举需要重写hashcode和equals吗
不需要

Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
//遍历map中的键  
  
for (Integer key : map.keySet()) {  
  
    System.out.println("Key = " + key);  
  
}  
  
//遍历map中的值  
  
for (Integer value : map.values()) {  
  
    System.out.println("Value = " + value);  
  
}

比较器的使用

package test;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Arrays;

public class ClassWork {
    public static void main(String[] args) {
       Goods [] goods={new Goods("pg",10),new Goods("xj",5),new Goods("sg",15)};
        Arrays.sort(goods);
        for (Goods i:goods
             ) {
            System.out.println(i);
        }


    }
}

@NoArgsConstructor
@AllArgsConstructor
@Data
class Goods implements Comparable<Goods>{
    private String  name;
    private Integer weight;

    @Override
    public int compareTo(Goods o) {
        if (this.weight>=o.weight)
        {
            return 1;
        }
        return -1;
    }
}

在这里插入图片描述

傻》n《瓜
关注
javaSE进阶综合项目：图书管理系统
m0_65014697的博客
11-19 616
javaSE进阶综合项目：图书管理系统
dljd javaSE进阶教材
03-28
### JavaSE进阶教材知识点概览 #### 一、数组基础与高级应用 **1.1 数组的定义** 数组是一种基本的数据结构，在Java中，它用于存储固定大小的同类型元素集合。数组中的每个元素可以通过索引进行访问，索引从0开始...
javaSE进阶
qq_43039936的博客
12-13 862
目录一级目录二级目录三级目录static修饰的静态成员变量是属于共享访问的static访问注意实现：代码块分为：懒汉单例通过调用变量来调懒汉单例只能通过调用方法来用继承，提高代码复用继承的特点：在子类方法中访问成员（成员变量、成员方法）满足：就近原则如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？什么是方法重写？@Override重写注解：方法重写注意事项和要求： 一级目录 二级目录 三级目录 static修饰的静态成员变量是属于共享访问的 如图所示，onLine
java se 进阶_JavaSE进阶
weixin_39621488的博客
02-24 146
11.2 Collection接口Collection 层次结构 中的根接口。常用方法：1、添加(1)add(Object obj)(2)addAll(Collection coll)2、获取有效元素的个数int size()3、清空集合void clear();4、是否包含某个元素(1)boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个对象c...
JavaSE进阶笔记
qq_68031670的博客
12-02 5554
JavaSE进阶笔记
javase进阶
weixin_51227224的博客
10-26 212
javase进阶 一、面向对象 1.1 知识框架 final abstract interface 抽象类与接口的区别 Object 包package、import 权限修饰 1.2 final 修饰类不可继承 修饰方法不可覆盖 修饰变量不可修改 需初始化‘ 修饰引用 地址不可修改 1.3 abstract 修饰类叫抽象类 修饰方法叫抽象方法 不可与final一起使用 抽象方法只存在抽象类 只需声明 不需实现 类中含有抽象方法 类也要被声明抽象类 抽象类不可实例化 可以有非抽象方法 1.4 in
JavaSE进阶 | 常用类学习（包装类和日期类详解）
m0_61933976的博客
07-12 1454
JavaSE进阶 | 常用类学习（包装类和日期类详解）
JavaSE进阶笔记（持续更新……）
qq_45629127的博客
08-14 687
Lambda表达式可以理解为匿名内部类的简化，是一种函数式编程思想，使用Lambda表达式的前提是：格式： 举例：有参无返回值 无参有返回值 有参有返回值 关于省略局部代码块：定义在方法内部，用大括号将一段代码括起来，用于控制变量的生命周期构造代码块：定义在构造方法之前，用于各个构造方法中共有的属性的初始化静态代码块：定义在成员变量处，用于解决重复创建对象导致的代码逻辑错误Math:基本运算类，包含基本的数学运算方法SystemSystem.exit()：退出虚拟机System.currentTimeMil
JavaSE进阶_01
mxyjajajavavava的博客
03-12 172
面向对象高级 分类思想 分类思想:分工协作,专人干专事. 信息管理系统分类: Student类 标准学生类,封装学生信息 StudentDao类 Dao(Data Access Object) 用于访问存储数据的数组或集合 StudentService类 用来进行业务逻辑的处理(如: 判断录入的ID是否存在) StudentController类 和用户打交道(接受用户需求,采集用户信息 .打印数据到控制台) 分包思想 包的概述 包 : 本质上就是文件夹 创建包: (单级包, 多级包)
JAVASE进阶
weixin_47027712的博客
04-29 596
static关键字 需求 /** * ①：某公司的员工信息系统中，需要定义一个公司的员工类Employee，包含如下信息 * 姓名：name，年龄：age , 所在部门名称dept * 静态属性company：记录公司的名称 * ②：需要在Employee类中定义一个方法showInfos() * 用于输出当前员工对象的信息，包含所有属性 * ③：需要在Employee类中定义定义一个通用的静态方法compareByAge() * 用于传输两个员工对象的年龄进入，并返回比较较大的年龄..
JavaSE进阶 面向对象多态
11-12
JavaSE 进阶 面向对象多态 在 JavaSE 中，面向对象多态是指同一个对象可以具有多种形态，例如一个人可以是老师、丈夫、父亲等。这种多态性是通过方法的重写和重载来实现的。 多态的形式有很多，例如： 1. 方法...
JavaSE进阶数组讲义
08-30
【JavaSE进阶数组讲义】深入解析 数组在Java编程语言中扮演着重要的角色，它是数据结构的基础，用于存储一组具有相同类型的元素。数组的特点包括： 1. **数组的本质**：数组是一种引用数据类型，它在内存中表现为...
JavaSE进阶 面向对象继承
11-12
JavaSE进阶面向对象继承 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为。继承的优点是可以提高代码的可重用性，减少代码冗余，提高开发效率。 1. 继承的定义：继承是指一个类继承另一个类的...
JAVASE 进阶篇-web资料整理
03-29
### JAVASE 进阶篇-web资料整理 #### WEB 标准 在深入探讨Web开发技术之前，我们首先需要理解什么是Web标准。Web标准是指一套规范文档，它们由万维网联盟（W3C）等组织制定，目的是为了确保Web内容能够在各种...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 393
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 508
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 780
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1144
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
JavaSE进阶：常用类深度解析
"动力节点的JavaSE进阶课程涵盖了Java编程中的常用类，包括String、StringBuffer、基础类型包装类、日期相关类、数字相关类、Random类和Enum。这些知识点对于深入理解和应用Java语言至关重要。" 在Java编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值