java对象

最新推荐文章于 2024-09-05 10:03:39 发布

东伯2580

最新推荐文章于 2024-09-05 10:03:39 发布

阅读量678

点赞数

分类专栏： java学习

本文链接：https://blog.csdn.net/butter__ly/article/details/116157550

版权

java学习专栏收录该内容

7 篇文章 1 订阅

订阅专栏

1.面向对象

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

抽象，

封装

封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访
问只能通过指定的方式。
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性
用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，
因而可以将应用程序修改带来的影响减少到最低限度

继承

新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新
类的基类(父类)。
派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增
加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。

多态

虚基类，

抛异常

throws

this关键字

this在类中表示当前类将来创建出的对象. 每个对象中都有一个属于自己的this,

1.区别成员变量和局部变量

2.调用类的方法

3.调用类的构造器

new关键字

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对
类中构造器的调用。

Student s = new Student();
1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋值)
2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)例如:显式赋值private String name = “tom”;
3)调用构造器
4)把对象内存地址值赋值给变量。(=号赋值操作)

构造器

c++中（构造函数）

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

必须和类的名字相同
必须没有返回类型,也不能写void

内存

方法区：类代码信息，静态变量static，字符串常量。所有线程共享

2.三大特性

2.1.封装

隐藏属性，暴露统一接口

2.2.继承

java是单继承

对某一批类的抽象，提高代码复用

关键字extends

public class student extends Person{
}

Object类所有类的基类

Super关键字

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问
或调用父类中的属性和方法。

public class Person{
    protected String name = "zs";
} 
public class Student extends Person{
    private String name = "lisi";
    public void tes(String name)t{
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

用super调用父类构造方法，必须是构造方法中的第一个语句。

super只能出现在子类的方法或者构造方法中。

super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

方法重写

\1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不
能被重写.
\2. 静态方法不能重写
\1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
\2. 父类的非静态方法不能被子类重写为静态方法；//编译出错
\3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

\1. 私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上
重写了。

重写的语法

\1. 方法名必须相同
\2. 参数列表必须相同
\3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
\4. 抛出异常类型的范围可以被缩小,但是不能被扩大
ClassNotFoundException —> Exception
\5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回
类型的子类型
例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的
子类型

重载编译时多态方法名相同，在同一个类中，参数列表不同目的：同一函数名实现不同参数计算

重写运行时多态存在继承关系，方法名和参数列表相同，返回值可以不同，但应为同一子类目的：覆盖父类方法的内容。

2.3.多态

目的：动态编译，在执行时才决定对象类型

c++中父类指针指向子类对象

java中1.父类引用指向任意子类对象

多态只针对方法，属性没有多态

三个条件：继承，方法重写，父类引用指向子类对象

除了final常量类，final方法，static方法，其他都是jvm在运行期间动态绑定

instanceof 子父类关系判断

System.out.println(x instanceof Y);

类型转换

1、父类引用可以指向子类对象，子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）
father；
其中father前面的（Son）必须添加，进行强制转换。
4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效
5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样
使代码变得简洁。体现了JAVA的抽象编程思想。

3.修饰符

1.static修饰符

1.1.static变量

1.在类中，使用static修饰成员变量，称为静态变量

	static静态变量	非静态变量
访问	属于类的，可以使用类名访问	属于对象的，必须使用对象访问
内存	在内存中只有一个，所有实例共享	每个实例都有一份，互不影响
分配时间	加载类的过程中为static静态变量分配内存	创建对象时分配内存

1.2.static方法

在类中，使用static修饰成员方法，称为静态方法

1.静态方法不可以直接访问类中的非静态变量和非静态方法，this和super在类中属于非静态的变量.(静态方法中不能使用)

非静态方法可以直接访问静态变量和静态方法（因为加载顺序的原因）

2.非静态方法可以访问类中所有的方法和变量

3.父类的静态方法可以被继承，但不能被子类重写，

父类的非静态方法不能被子类重写为静态方法；

1.3静态代码块

public class Person {
    {
    //代码块(匿名代码块)
    } s
    tatic{
    //静态代码块
    }
}

因为没有名字,在程序并不能主动调用这些代码块。
匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的
时候都会自动执行.
静态代码块是在类加载完成之后就自动执行,并且只执行一次.
注:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次.

public class Person {
{
System.out.println("匿名代码块");
} s
tatic{
System.out.println("静态代码块");
} p
ublic Person(){
System.out.println("构造器");
}
} m
ain:
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
//输出
静态代码块
匿名代码块
构造器

匿名代码块
构造器

匿名代码块
构造器

【匿名代码块和静态代码块的作用】
匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块
使用的并不多。
静态代码块的作用是给类中的静态成员变量初始化赋值。
例如:

public class Person {
public static String name;
    static{
    	name = "tom";
    } 
    public Person(){
    	name = "zs";
    }
} m
ain:
System.out.println(Person.name);//tom

注：在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静
态变量可以不创建对象而直接使用类名来访问.

1.4创建和初始化对象的过程

Student s = new Student();

【Student类之前没有进行类加载】
\1. 类加载,同时初始化类中静态的属性
\2. 执行静态代码块
\3. 分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
\4. 调用Student的父类构造器
\5. 对Student中的属性进行显示赋值(如果有的话)
\6. 执行匿名代码块
\7. 执行构造器
\8. 返回内存地址

注:子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候

【Student类之前已经进行了类加载】
1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
2.调用Student的父类构造器
3.对Student中的属性进行显示赋值(如果有的话)
4.执行匿名代码块
5.执行构造器
6.返回内存地址

1.5静态导入

java包的静态导入，使用import static代替import，意思是导入这类里的静态方法

import static java.lang.Math.PI;
System.out.println(PI);//可以直接使用

2.final修饰符

2.1修饰类

使用final修饰的类不能被继承，没有子类

2.2修饰方法

使用final修饰的方法可以被继承，但不能被子类重写。

例如:每个类都是Object类的子类,继承了Object中的众多方法,在子类中可以重写toString方法、equals方
法等,但是不能重写getClass方法 wait方法等,因为这些方法都是使用fianl修饰的

2.3修饰变量

使用final修饰变量表示常量，只能被赋值一次，

1.final修饰局部变量，常量不能二次赋值

2.final修饰成员变量-非静态成员变量：只能赋值一次，但有三个位置可以进行这次赋值

声明的同时赋值
匿名代码块中赋值
构造器中赋值

3.final修饰成员变量-static静态成员变量：只能赋值一次，但有两个位置可以进行这次赋值

声明的同时赋值
静态代码块中赋值

4.final修饰引用变量

final Student s = new Student();
//编译通过
s.setName("tom");
s.setName("zs");
//编译报错,不能修改引用s指向的内存地址
s = new Student();

3.abstract修饰符

抽象类目的就是为了在多态时抽调一个公有框架，方便调用，同一接口函数，规定必须让子类重写实现。

多态的目的是为了让父类指针指向子类对象，实现动态编译，在运行时指定对象类型，

3.1抽象方法，抽象类关系

抽象类中可以没有抽象方法

有抽象方法的类一定要声明为抽象类

3.2实现

声明类的同时,加上abstract修饰符就是抽象类
声明方法的时候,加上abstract修饰符,并且去掉方法的大口号,同时结尾加上分号,该方法就是抽象方法。

public abstract class Action{
	public abstract void doSomething();//不需要实现
}

3.3特点

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

注:子类继承抽象类后,需要实现抽象类中没有实现的抽象方法,否则这个子类也要声明为抽象类。

相当于c++中virtual关键字，虚基类，虚函数表，虚指针，

3.4思考

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zHEEgGQ9-1619421919957)(C:\Users\Uncle\AppData\Roaming\Typora\typora-user-images\image-20210426103958807.png)]

4.接口 interface

面向接口编程，接口就是规范，接口都需要实现类，利用接口实现多继承

4.1接口和抽象类的区别

抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接
口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。

声明类的关键字是class,声明接口的关键字是interface。
抽象类是用来被继承的,java中的类是单继承，只能有一个父类。
类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态
一个父类的引用,可以指向这个父类的任意子类对象
注:继承的关键字是extends
接口是用来被类实现的,java中的接口可以被多实现。
类A实现接口B、C、D、E…,那么类A的对象就属于B、C、D、E等类型了,可以使用多态
一个接口的引用,可以指向这个接口的任意实现类对象
注:实现的关键字是implements

4.2接口

1.方法，都是抽象方法，接口中可以不写方法，但如果有方法，必须是抽象方法

2.变量，必须是静态常量，public static final修饰，声明时必须幅值

public interface Action{
    public static final String NAME = "tom";
    //默认就是public static final修饰的，可以不显示表达
    int AGE = 20;
} 
main:
System.out.println(Action.NAME);
System.out.println(Action.AGE);

4.3一个类实现implements多个接口

public class Student implements A,B,C,D{
    //Student需要实现接口A B C D中所有的抽象方法
    //否则Student类就要声明为抽象类,因为有抽象方法没实现
} 
main:
A s1 = new Student();
B s2 = new Student();
C s3 = new Student();
D s4 = new Student();
必要时可以类型强制转换
if(s1 instanceof B){
	((B)s1).run();
}

4.4一个接口继承extends多个父接口

public interface C extends A,B{
	public void testC();
}

4.5接口的作用

接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建
【接口名】【对象名】= new 【实现接口的类】
这样你想用哪个类的对象就可以new哪个对象了，不需要改原来的代码。
假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，new
b（）就是用b的方法
这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同
总结：
1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接
口中的成员变量为常量(大写,单词之间用"_"分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象
类

8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这
个接口的类的实例
9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
【实例】

interface SwimInterface{
    void swim();
    } 
        class Fish{
        int fins=4;
    } 
	class Duck {
        int leg=2;
        void egg(){};
} 
class Goldfish extends Fish implements SwimInterface {
    @Override
    public void swim() {
   	 System.out.println("Goldfish can swim ");
    }
} 
class SmallDuck extends Duck implements SwimInterface {
    public void egg(){
    System.out.println("SmallDuck can lay eggs ");
    }
    @Override
    public void swim() {
    System.out.println("SmallDuck can swim ");
    }
    } 
    public class InterfaceDemo {
    public static void main(String[] args) {
    Goldfish goldfish=new Goldfish();
    goldfish.swim();
    SmallDuck smallDuck= new SmallDuck();
    smallDuck.swim();
    smallDuck.egg();
    }
}