Java基础扫盲

最新推荐文章于 2024-04-01 05:27:25 发布

去海边钓猪

最新推荐文章于 2024-04-01 05:27:25 发布

阅读量232

点赞数 2

分类专栏： Java

本文链接：https://blog.csdn.net/super1223/article/details/119452531

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

面向对象

面向对象编程的三特性

继承：使用现有的类对其所有属性和功能，在无需重新编写原来的类的基础上对其扩展。

继承作为面向对象编程的特性，可以大大的减少代码的冗余，实现代码的复用，继承了父类的子类可以继承其所有的属性和功能，并且可以对其进行拓展。实现其也要注意一些事项

public和protected属性或者方法，可以直接继承并使用。
private权限的属性和方法不可被继承。

继承的实现，其本质都是通过super来实现对父类对象的引用，super代表的是父类的一个引用对象。对于子类使用父类的属性和方法实际上都是调用了super方法来实现的。即引用对象指向父类的实际地址，本质上还是同一个内存地址上的对象。

栗子

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
        // 本质上是 进行了super.show()方法，使用父类对象的引用调用其父类对象的show()方法
        System.out.println(student.name);
        // 本质上是 进行了super.name调用，使用父类对象的引用调用了父类对象的属性
    }
}

class Person {
    public String name;

    public void show(){
        System.out.println("生而为人");
    }
}
class Student extends Person {
}

对于方法，可以采用重写的方式进行重写，重写后，可以选择在其父类的基础上进行扩展，也可以直接修改其方法。

//拓展性重写
@Override
public void show(){
	super.show();    
    System.out.println("生而为人");
}
//修改性重写
@Override
public void show(){
	System.out.println("不当人");
}

在构造函数中，会默认调用父类的构造方法，因为父类中的属性也需要被初始化，而子类中构造函数的形参只是为了给父类传参，并不具有其他任何意义。

栗子：

public class TestBlock {
    public static void main(String[] args) {
        Student student = new Student("张小", "12", "23");
        System.out.println(student.toString());
    }
}

abstract class Person {
    private String name;
    private String age;

    public Person(String name, String age) {
        this.age = age;
        this.name = name;
    }
}

class Student extends Person {

    private String no;

    public Student(String name, String age, String no) {
        super(name, age);
        this.no = no;
    }

    @Override
    public String toString() {
        return "Student{" +
                "no='" + no + '\'' +
                '}';
    }
}

封装：用权限修饰符控制自己的属性和方法对可信的对象开放，对不可信的对象隐藏。

在java中，使用权限修饰符private，public，protected三个权限修饰符来控制对类中属性和方法的访问权限进行控制，从而实现封装的目的。

修饰符	同类	同包	子类	无关类
public	yes	yes	yes	yes
protected	yes	yes	yes	no
default	yes	yes	no	no
private	yes	no	no	no

多态：多态是同一个行为具有多个不同表现形式或形态的能力，实现多态的方式是重写。

多态在java中表现为父类的引用可以指向子类的实例化对象，在继承中父类中，子类通过重写父类的方法，使得父类在调用其方法时，可以根据指向对象不同，实现方法动态的的发生改变。

重载算不算一种多态？

这算是一个争议比较大的问题了，因为在定义多态时，实现多态需要具有三个条件（父类引用指向子类对象，继承，重写），从这个定义来讲的话，重载和这些东西并不相关。并且，作为一门面向对象语言，多态性应该时面向对象的，而重载是一个面向方法的概念。

但是从设计的理念来讲，多态是一种行为具有多种不同的表现形式，而重载实现中恰好完美的实现了这一点，它发生在编译时期，静态的将重载的方法标识为不同的方法，并且表现除不同的功能，从而实现我们的多态概念，这也被一部分人认为是静态的编译时动态。

而重写实现的多态时一种运行时多态，在运行时，通过父类引用动态的指向不同的子类对象从而实现多态。如果java不提供重写机制，即引用不能随意指向，那么如何实现多态呢？无疑也同样可以在编译的时候为父类的方法根据子类重载来实现，但是这会造成巨大的资源损耗。

所以说，从狭义上来讲，重载不是一种多态，而重写是一种多态。

栗子

public class TestBlock {
    public static void main(String[] args) {
        Person student = new Student();
        student.study();
    }
}

class Person {
    public void study(){
        System.out.println("I like Study");
    }
}

class Student extends Person {
    public void study1(){
        System.out.println("I also like study");
    }
}

基本类型与引用类型

基本类型：八大基本类型为：byte/8、short/16、int/32、long/64、float/32、double/64、char/16、boolean/8，其中byte、short、int、long是整型。float、double是浮点型，char是字符型，boolean是布尔型。

引用类型：java为每种基本类型都提供了对应的封装类型，分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean。引用类型是一种对象类型,它的值是指向内存空间的引用，就是地址。

基本数据类型与引用类型对应。

byte	Byte
short	Short
int	Interger
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

除了基本类型的引用，还有其他引用类型：String类型，对象类型，数组类型等。本质上都是对象的引用类型。

Java从jdk1.5开始引入自动装箱和拆箱,使得基本数据类型与引用类型之间相互转换变得简单。

自动装箱：java自动将原始类型转化为引用类型的过程，自动装箱时编译器会调用valueOf方法,将原始类型转化为对象类型。

自动拆箱：java自动将引用类型转化为原始类型的过程，自动拆箱时编译器会调用intValue(),doubleValue()这类的方法将对象转换成原始类型值。

自动装箱主要发生在两种情况：一种是赋值时，一种是方法调用时。

a.赋值时

Interger a = 3; //自动装箱
//相当于
int a;
a = Integer.valueOf(3);

int b = a;	//自动拆箱
//相当于
int b = a.intValue();

b.方法调用

public Integer query(Integer a){
return a;
}
query(3); //自动装箱
int result = query(3); //自动拆箱

参考[基本类型和引用类型](

接口与继承

接口和抽象类详解（参考100题）

抽象类可以存在普通成员函数，而接口中只能存在public abstract 方法。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
抽象类只能继承一个，接口可以实现多个。

接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有

什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，

但不对如何实现行为进行限制。

而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行

为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实

现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己

实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执

行）。

抽象类是对类本质的抽象，表达的是 is a 的关系，比如： BMW is a Car 。抽象类包含并实现子类的通

用特性，将子类存在差异化的特性进行抽象，交由子类去实现。

而接口是对行为的抽象，表达的是 like a 的关系。比如： Bird like a Aircraft （像飞行器一样可以

飞），但其本质上 is a Bird 。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、

是如何实现的，接口并不关心。

接口是对类行为的进行约束，所有接口的实现类都必须实现接口中的所有方法，且接口本身不实现任何方法，都为抽象方法。接口对方法进行限制，对其实现方式不进行限制，可以实现多个接口对接口的方式进行实现

抽象类是对类代码进行复用，当有多个类有相同特性时（方法，属性）可以将其抽取为抽象类，只需要继承该类就可以拥有父类的所有特性，子类必须实现父类的抽象方法，并且可以对普通方法进行重写。同时，子类也可以实现自己所独有的方法

因为抽象类的继承是基于继承来实现的，所以其功能更加丰富。

栗子

//学生有着人的特性，抽取出来
public class TestBlock {
    public static void main(String[] args) {
        Student student = new Student("张小", "12", "23");
        student.walk();
        student.show();
    }
}

abstract class Person {
    private String name;
    private String age;

    public Person(String name, String age) {
        this.age = age;
        this.name = name;
    }
    public abstract void walk();
}

class Student extends Person {

    private String no;

    public String getNo() {
        return no;
    }

    public Student(String name, String age, String no) {
        super(name, age);
        this.no = no;
    }

    public void show() {
        System.out.println("学生爱学习");
    }

    @Override
    public void walk() {
        System.out.println("人会走路");
    }
}

// 只对学生的行为做约束，必须要按格式实现接口的方法。
public class TestBlock {
    public static void main(String[] args) {
        Student student = new Student();
        student.walk();
        student.homework();
        student.study();
    }
}

interface Person {

    public void walk();
}

interface Son {
    public void homework();
}
class Student implements Person, Son{

    private String name;
    private String age;

    @Override
    public void walk() {
        System.out.println("我会走路");
    }

    @Override
    public void homework() {
        System.out.println("我要做家务");
    }
    public void study(){
        System.out.println("我爱学习");
    }
}

static关键字

1.静态资源只能调用静态资源
2.非静态资源既可以调用静态资源,也可以调用非静态资源

3.可以修饰成员变量与成员方法

4.随着类的加载而加载，优先于对象加载

5.只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失

6.静态资源也叫做类资源,全局唯一,被全局所有对象共享

7.可以直接被类名调用

8.static不能和this或者super共用，因为有static时可能还没有对象

参考 static关键字

final关键字

final可以修饰类，方法，成员变量
初衷：java出现继承后，子类可以更改父类的功能，当父类功能不许子类改变时,可以利用final关键字修饰父类。

被final修饰的类，不能被继承
被final修饰的方法，不能被重写
被final修饰的变量是个常量，值不能被改变
常量的定义形式：final 数据类型常量名 = 值

参考final关键字

代码块

静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
局部代码块：方法里的代码块，限制局部变量的范围，当方法被调用时加载

执行顺序：静态代码块 > 构造代码块 > 构造函数 > 局部代码块

栗子

public class TestBlock {
 public static void main(String[] args) {
     Person p = new Person();
     Person p2 = new Person();
     p.sleep();
 }
}
class Person{
 static{
     System.out.println("我是静态代码块~");
 }
 {
     System.out.println("我是构造代码块~");
 }
 public Person(){
     System.out.println("我是构造方法~");
 }
 public void sleep(){
     System.out.println("我是普通方法~快醒醒，起来嗨~");
     {
         System.out.println("我是局部代码块~");
     }
 }
}

执行顺序

我是静态代码块~
我是构造代码块~
我是构造方法~
我是构造代码块~
我是构造方法~
我是普通方法_{快醒醒，起来嗨}
我是局部代码块~

参考代码块相关

接口和抽象类

抽象类可以存在普通成员函数，而接口中只能存在public abstract 方法。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
抽象类只能继承一个，接口可以实现多个。

接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有

什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，

但不对如何实现行为进行限制。

而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行

为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实

现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己

实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执

行）。

抽象类是对类本质的抽象，表达的是 is a 的关系，比如： BMW is a Car 。抽象类包含并实现子类的通

用特性，将子类存在差异化的特性进行抽象，交由子类去实现。

而接口是对行为的抽象，表达的是 like a 的关系。比如： Bird like a Aircraft （像飞行器一样可以

飞），但其本质上 is a Bird 。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、

是如何实现的，接口并不关心。

因为抽象类的继承是基于继承来实现的，所以其功能更加丰富。

栗子

//学生有着人的特性，抽取出来
public class TestBlock {
 public static void main(String[] args) {
     Student student = new Student("张小", "12", "23");
     student.walk();
     student.show();
 }
}

abstract class Person {
 private String name;
 private String age;

 public Person(String name, String age) {
     this.age = age;
     this.name = name;
 }
 public abstract void walk();
}

class Student extends Person {

 private String no;

 public String getNo() {
     return no;
 }

 public Student(String name, String age, String no) {
     super(name, age);
     this.no = no;
 }

 public void show() {
     System.out.println("学生爱学习");
 }

 @Override
 public void walk() {
     System.out.println("人会走路");
 }
}

// 只对学生的行为做约束，必须要按格式实现接口的方法。
public class TestBlock {
 public static void main(String[] args) {
     Student student = new Student();
     student.walk();
     student.homework();
     student.study();
 }
}

interface Person {

 public void walk();
}

interface Son {
 public void homework();
}
class Student implements Person, Son{

 private String name;
 private String age;

 @Override
 public void walk() {
     System.out.println("我会走路");
 }

 @Override
 public void homework() {
     System.out.println("我要做家务");
 }
 public void study(){
     System.out.println("我爱学习");
 }
}

java四大引用类型

强引用：如果一个对象具有强引用，那就类似于必不可少的物品，不会被垃圾回收器回收。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不回收这种对象。

软引用：对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。

弱引用：弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。

虚引用：虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之关联的引用队列中。

引用类型	被回收时间	用途	生存时间
强引用	从来不会	对象的一般状态	JVM停止运行时
软引用	内存不足时	对象缓存	内存不足时
弱引用	jvm垃圾回收时	对象缓存	gc运行后
虚引用	未知	未知	未知

参考四大引用类型

去海边钓猪

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java基础扫盲

目录面向对象基本类型与引用类型接口与继承static关键字final关键字代码块接口和抽象类java四大引用类型面向对象面向对象编程的三特性继承：使用现有的类对其所有属性和功能，在无需重新编写原来的类的基础上对其扩展。继承作为面向对象编程的特性，可以大大的减少代码的冗余，实现代码的复用，继承了父类的子类可以继承其所有的属性和功能，并且可以对其进行拓展。实现其也要注意一些事项public和protected属性或者方法，可以直接继承并使用。private权限的属性和方法不可被继承。
复制链接

扫一扫

专栏目录